tickmarkr 1.37.0 → 1.38.0

package/README.md

@@ -13,17 +13,12 @@ cursor-agent, opencode, grok, pi) by cost and capability, dispatches work in iso
 with full visibility into routing decisions, worker progress, and gate verdicts — or run headless
 and review the audit trail 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 -->
-
 ## 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)
+- new engagements consolidate to a `tickmarkr/<runId>` branch — never main
 - gates never trust worker claims; tickmarkr verifies everything itself
 - state is files + git only; no DB, no services
 - worker/judge/review/consult prompts end with machine-parseable trailers

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

@@ -22,14 +22,14 @@ 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 isJudge = false;
         try {
-            isJudge = /DROVR-JUDGE/.test(readFileSync(promptFile, "utf8"));
+            isJudge = /TICKMARKR-JUDGE/.test(readFileSync(promptFile, "utf8"));
         }
         catch {
             // unreadable promptFile: can't detect role; serve static values (legacy headless-call behavior)
@@ -45,7 +45,7 @@ export class FakeAdapter {
             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);
@@ -61,11 +61,11 @@ export class FakeAdapter {
         // 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)}}))`)}`
+            ? `; 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 }))}`;
+            : `bash -c ${shq(step.shell)}; echo ${shq(`TICKMARKR_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.
@@ -73,7 +73,7 @@ export class FakeAdapter {
     // 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 +93,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];
@@ -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;
@@ -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/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.

package/dist/cli/commands/compile.js

@@ -18,7 +18,7 @@ export async function compile(argv, cwd = process.cwd()) {
     // as a second daemon. Read-only check — compile never acquires/holds (it's instantaneous).
     const stateDir = stateDirName(cwd);
     if (isRunLockLive(cwd))
-        throw new Error(`${stateDir}/graph.lock is held by another drovr run, or is a stale/garbage lock — refusing to overwrite graph.json. If no run is active, run \`drovr unlock\`.`);
+        throw new Error(`${stateDir}/graph.lock is held by another tickmarkr run, or is a stale/garbage lock — refusing to overwrite graph.json. If no run is active, run \`tickmarkr unlock\`.`);
     saveGraph(cwd, g);
     return `compiled ${src} → ${stateDir}/graph.json (${g.tasks.length} tasks, source ${g.spec.source}, hash ${g.spec.hash.slice(0, 12)})`;
 }

package/dist/cli/commands/doctor.js

@@ -1,7 +1,7 @@
 import { writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { allAdapters, probeAll, probeModels, readAutoPrefer, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
-import { drovrDir, stateDirName } from "../../graph/graph.js";
+import { tickmarkrDir, stateDirName } from "../../graph/graph.js";
 import { modelLints, suggestOverlay, ttyVisual } from "../../adapters/model-lints.js";
 import { DEFAULT_CONFIG, loadConfig, overlayPreferShapes } from "../../config/config.js";
 import { HerdrDriver } from "../../drivers/herdr.js";
@@ -99,14 +99,14 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     const servable = servableExclusions(cfg, adapters, health);
     if (servable.length)
         rows.push(`  ! ${servabilityLine(servable)}`);
-    // MODEL-05/06: print-only drift fragment; advisory, whole-line-commented additions, drovr NEVER applies it.
+    // MODEL-05/06: print-only drift fragment; advisory, whole-line-commented additions, tickmarkr NEVER applies it.
     // TTY gets a one-line summary + the fragment as a file (the full dump drowned everything else,
     // v1.33.1 onboarding); machine/CI surface keeps the inline dump — layout is pinned by tests.
     const frag = suggestOverlay(cfg, health, adapters, stateDirName(cwd));
     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/cli/commands/init.js

@@ -4,8 +4,8 @@ import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
 import { allAdapters, formatDoctorAgeForInit, formatDoctorReport, initDoctorReuse } from "../../adapters/registry.js";
 import { configTemplate, DEFAULT_CONFIG, globalConfigDir, loadConfig } from "../../config/config.js";
-import { specTemplate } from "../../compile/native.js";
-import { drovrDir } from "../../graph/graph.js";
+import { LEGACY_PREFIX, specTemplate } from "../../compile/native.js";
+import { tickmarkrDir } from "../../graph/graph.js";
 import { doctor } from "./doctor.js";
 const AGENT_SKILLS = ["tickmarkr-loop", "tickmarkr-auto"];
 const DOCS_BEGIN = "<!-- tickmarkr:agent-docs begin -->";
@@ -52,7 +52,8 @@ async function installAgentFiles(cwd, force, docs, notes) {
         const agents = join(cwd, "AGENTS.md");
         const docPath = existsSync(claude) || !existsSync(agents) ? claude : agents;
         const current = existsSync(docPath) ? readFileSync(docPath, "utf8") : "";
-        if (current.includes(DOCS_BEGIN) || current.includes(DOCS_END)) {
+        if (current.includes(DOCS_BEGIN) || current.includes(`<!-- ${LEGACY_PREFIX}:agent-docs begin -->`)
+            || current.includes(DOCS_END) || current.includes(`<!-- ${LEGACY_PREFIX}:agent-docs end -->`)) {
             notes.push(`kept existing tickmarkr agent docs in ${docPath}`);
         }
         else if (docs || await confirm(`Append tickmarkr agent docs to ${docPath}?`)) {
@@ -126,7 +127,7 @@ export async function init(argv, cwd = process.cwd()) {
     else {
         notes.push(`kept existing ${globalPath}`);
     }
-    const repoConfigPath = join(drovrDir(cwd), "config.yaml");
+    const repoConfigPath = join(tickmarkrDir(cwd), "config.yaml");
     const repoConfigExists = existsSync(repoConfigPath);
     if (repoConfigExists)
         notes.push(`kept existing ${repoConfigPath}`);
@@ -134,12 +135,16 @@ export async function init(argv, cwd = process.cwd()) {
     if (existsSync(specPath)) {
         notes.push(`kept existing ${specPath}`);
     }
-    else if (existsSync(join(cwd, "drovr.spec.md"))) {
-        notes.push(`kept existing ${join(cwd, "drovr.spec.md")}`);
-    }
     else {
-        writeFileSync(specPath, specTemplate());
-        notes.push(`wrote ${specPath}`);
+        const legacySpec = join(cwd, `${LEGACY_PREFIX}.spec.md`);
+        if (existsSync(legacySpec)) {
+            writeFileSync(specPath, readFileSync(legacySpec, "utf8"));
+            notes.push(`wrote ${specPath}`);
+        }
+        else {
+            writeFileSync(specPath, specTemplate());
+            notes.push(`wrote ${specPath}`);
+        }
     }
     const fresh = values.fresh ?? false;
     const { reuse, ageMs, health } = initDoctorReuse(cwd, fresh);

package/dist/cli/commands/profile.js

@@ -1,22 +1,22 @@
 import { writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { loadConfig } from "../../config/config.js";
-import { drovrDir, stateDirName } from "../../graph/graph.js";
+import { tickmarkrDir, stateDirName } from "../../graph/graph.js";
 import { learnedScore, MIN_SAMPLES, cellsOf } from "../../route/profile.js";
 import { Journal, loadRoutingProfile, readProfileCursor, RUNS_WINDOW } from "../../run/journal.js";
-// drovr profile — inspect (show) and forget (reset) the derived learned-routing profile (VIS-03).
+// tickmarkr profile — inspect (show) and forget (reset) the derived learned-routing profile (VIS-03).
 // Read-only class like plan/status/report: no run lock. `reset` writes ONE cursor scalar, nothing else.
 export async function profile(argv, cwd = process.cwd()) {
     return argv[0] === "reset" ? reset(cwd) : show(cwd);
 }
-// Non-destructive reset (T-13-06): a one-line runId cutoff at .drovr/profile-since. NEVER deletes,
+// Non-destructive reset (T-13-06): a one-line runId cutoff at .tickmarkr/profile-since. NEVER deletes,
 // truncates, or rotates any telemetry — the profile is derived (PROF-01), so there is nothing to delete;
-// the cursor only bounds loadRoutingProfile's telemetry window. drovrDir guarantees .drovr exists and
+// the cursor only bounds loadRoutingProfile's telemetry window. tickmarkrDir guarantees .tickmarkr exists and
 // blanket-gitignores it, so the cursor is never git-addable. Opaque string: used only in a runId > compare.
 function reset(cwd) {
     const cursor = Journal.latestRunId(cwd) ?? ""; // empty repo ⇒ empty cursor ⇒ readProfileCursor === undefined
     const stateDir = stateDirName(cwd);
-    const path = join(drovrDir(cwd), "profile-since");
+    const path = join(tickmarkrDir(cwd), "profile-since");
     writeFileSync(path, cursor + "\n");
     return [
         cursor
@@ -27,7 +27,7 @@ function reset(cwd) {
     ].join("\n");
 }
 // Inspection surface: preview:true bypasses the routing.learned:off short-circuit so `show` renders the
-// profile even under the default off — same trust ramp as `drovr plan`. The routing path stays inert.
+// profile even under the default off — same trust ramp as `tickmarkr plan`. The routing path stays inert.
 function show(cwd) {
     const cfg = loadConfig(cwd);
     const cursor = readProfileCursor(cwd);

package/dist/cli/commands/status.js

@@ -1,3 +1,4 @@
+import { BANNER } from "../../brand.js";
 import { blockedTasks, loadGraph, pendingTasks } from "../../graph/graph.js";
 import { GATE_NAMES } from "../../graph/schema.js";
 import { Journal } from "../../run/journal.js";
@@ -211,7 +212,7 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
     for (let i = 0; i < iterations; i++) {
         const frame = renderFrame(cwd);
         if (tty)
-            process.stdout.write(`\x1b[2J\x1b[H${frame}\n\x1b[2m watching · refresh ${REFRESH_MS / 1000}s · ^C to quit\x1b[0m`);
+            process.stdout.write(`\x1b[2J\x1b[H${BANNER}${frame}\n\x1b[2m watching · refresh ${REFRESH_MS / 1000}s · ^C to quit\x1b[0m`);
         else
             process.stdout.write(frame + sep);
         if (bounded)

package/dist/cli/commands/unlock.js

@@ -1,6 +1,6 @@
 import { unlockRun } from "../../run/lock.js";
 // LOCK-03: thin formatter over unlockRun. A live-holder refusal propagates as the throw — the
-// dispatcher prints `drovr unlock: …` and exits 1 (src/cli/index.ts).
+// dispatcher prints `tickmarkr unlock: …` and exits 1 (src/cli/index.ts).
 export async function unlock(_argv, cwd = process.cwd()) {
     const r = unlockRun(cwd);
     if (!r.held)

package/dist/cli/index.d.ts

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 export type CommandMap = Record<string, (argv: string[]) => Promise<string>>;
 export declare const COMMANDS: CommandMap;
-export declare const BANNER: string;
-export declare const USAGE = "tickmarkr \u2014 spec-driven orchestration harness for AI coding agents\nusage: tickmarkr <command>\n  init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs\n  doctor        re-probe adapters, herdr, auth; print capability matrix\n  compile <src> spec \u2192 .drovr/graph.json (fails without acceptance criteria)\n  scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)\n  plan          dry-run routing table + cost estimate + floor lints\n  run           execute the graph (--concurrency N --driver herdr|subprocess --route-strict)\n  status        live run state\n  resume <id>   continue a run from its journal\n  report <id>   cost/quality report (--md for committable execution record)\n  profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)\n  unlock        remove a stale/garbage run lock (refuses if the holder is alive)\n  approve <id> <task>  approve a parked human gate (--by <name> --reason <text>); takes effect on resume";
+export declare const USAGE = "tickmarkr \u2014 spec-driven orchestration harness for AI coding agents\nusage: tickmarkr <command>\n  init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs\n  doctor        re-probe adapters, herdr, auth; print capability matrix\n  compile <src> spec \u2192 .tickmarkr/graph.json (fails without acceptance criteria)\n  scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)\n  plan          dry-run routing table + cost estimate + floor lints\n  run           execute the graph (--concurrency N --driver herdr|subprocess --route-strict)\n  status        live run state\n  resume <id>   continue a run from its journal\n  report <id>   cost/quality report (--md for committable execution record)\n  profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)\n  unlock        remove a stale/garbage run lock (refuses if the holder is alive)\n  approve <id> <task>  approve a parked human gate (--by <name> --reason <text>); takes effect on resume";
 export declare function dispatch(cmd: string | undefined, argv: string[], commands?: CommandMap): Promise<{
     out: string;
     code: number;