tickmarkr 1.36.0 → 1.38.0

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/adapters/types.js

@@ -53,4 +53,4 @@ export const QUOTA_RE = /rate.?limit|quota|usage limit|out of credits|insufficie
 // operator-facing lint text and persisted to doctor.json — defense-in-depth for MODEL-05 (config
 // suggestions that could reach a shell). Covers observed ids incl. zai-coding-plan/glm-5.2,
 // gpt-5.6-sol, composer-2.5, gpt-5.3-codex; non-conforming (ANSI/control/shell-metachar) ids dropped.
-export const MODEL_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._/:\[\]=,-]*$/;
+export const MODEL_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._/:[\]=,-]*$/;

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,7 +1,7 @@
 #!/usr/bin/env node
 export type CommandMap = Record<string, (argv: string[]) => Promise<string>>;
 export declare const COMMANDS: CommandMap;
-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;

package/dist/cli/index.js

@@ -17,11 +17,12 @@ export const COMMANDS = {
     init, doctor, compile, scope, plan, run, status, resume, report, profile, unlock, approve,
 };
 const HELP_CMDS = new Set(["help", "-h", "--help"]);
+import { BANNER } from "../brand.js";
 export const USAGE = `tickmarkr — spec-driven orchestration harness for AI coding agents
 usage: tickmarkr <command>
   init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs
   doctor        re-probe adapters, herdr, auth; print capability matrix
-  compile <src> spec → .drovr/graph.json (fails without acceptance criteria)
+  compile <src> spec → .tickmarkr/graph.json (fails without acceptance criteria)
   scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)
   plan          dry-run routing table + cost estimate + floor lints
   run           execute the graph (--concurrency N --driver herdr|subprocess --route-strict)
@@ -32,14 +33,15 @@ usage: tickmarkr <command>
   unlock        remove a stale/garbage run lock (refuses if the holder is alive)
   approve <id> <task>  approve a parked human gate (--by <name> --reason <text>); takes effect on resume`;
 // pure, testable dispatcher: resolves a command, forwards argv, shapes the result — no side effects.
-// unknown/missing cmd → USAGE (exit 1 if a cmd was typed, 0 for bare `drovr`); a handler throw becomes
-// a one-line `drovr <cmd>: <message>` (never a raw stack) at exit 1.
+// unknown/missing cmd → USAGE (exit 1 if a cmd was typed, 0 for bare `tickmarkr`); a handler throw becomes
+// a one-line `tickmarkr <cmd>: <message>` (never a raw stack) at exit 1.
 export async function dispatch(cmd, argv, commands = COMMANDS) {
+    const usage = process.stdout.isTTY ? BANNER + USAGE : USAGE;
     if (!cmd || HELP_CMDS.has(cmd))
-        return { out: USAGE, code: 0 };
+        return { out: usage, code: 0 };
     const fn = commands[cmd];
     if (!fn)
-        return { out: USAGE, code: 1 };
+        return { out: usage, code: 1 };
     try {
         return { out: await fn(argv), code: 0 };
     }
@@ -49,7 +51,7 @@ export async function dispatch(cmd, argv, commands = COMMANDS) {
 }
 /* v8 ignore start -- binary entry: printing + process.exit side effects, not unit-testable (ROADMAP crit 2) */
 // node realpaths the main module (import.meta.url) but argv[1] keeps the symlink path —
-// a globally-linked `drovr` bin silently no-oped here (OBS-10); compare realpaths
+// a globally-linked `tickmarkr` bin silently no-oped here (OBS-10); compare realpaths
 const argv1Real = (() => { try {
     return process.argv[1] ? realpathSync(process.argv[1]) : "";
 }
@@ -60,7 +62,7 @@ if (argv1Real && import.meta.url === pathToFileURL(argv1Real).href) {
     const [cmd, ...argv] = process.argv.slice(2);
     dispatch(cmd, argv).then(({ out, code }) => {
         // byte-identical streams: usage + success → stdout; a handler throw → stderr (original behavior)
-        (out === USAGE || code === 0 ? console.log : console.error)(out);
+        (out.endsWith(USAGE) || code === 0 ? console.log : console.error)(out);
         if (code !== 0)
             process.exit(code);
     });

package/dist/compile/gsd.js

@@ -3,7 +3,7 @@ import { basename, dirname, isAbsolute, join, relative } from "node:path";
 import { parse as parseYaml } from "yaml";
 import { TIERS, validateGraph } from "../graph/schema.js";
 import { CompileError, assertWriteScope, inferShape, sha256 } from "./common.js";
-// GSD artifact front-end (spec v1.3): one GSD *plan* is one drovr *task* — a plan is
+// GSD artifact front-end (spec v1.3): one GSD *plan* is one tickmarkr *task* — a plan is
 // worktree-sized; its inner <task> steps stay in the worker prompt via context[0] = the plan file.
 // Artifact-level only: parses .planning/ markdown, never GSD repo/command internals.
 const PLAN_SUFFIX = "-PLAN.md";

package/dist/compile/index.js

@@ -2,7 +2,7 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { CompileError } from "./common.js";
 import { compileGsd, isGsdPhaseDir } from "./gsd.js";
-import { compileNative, NATIVE_MARKER } from "./native.js";
+import { compileNative, TICKMARKR_NATIVE_MARKER } from "./native.js";
 import { compilePrd } from "./prd.js";
 import { compileSpecKit } from "./speckit.js";
 function detect(src) {
@@ -15,8 +15,14 @@ function detect(src) {
     }
     if (src.endsWith("-PLAN.md"))
         return "gsd"; // before the generic .md → prd rule
-    if (src.endsWith(".md"))
-        return existsSync(src) && NATIVE_MARKER.test(readFileSync(src, "utf8")) ? "native" : "prd";
+    if (src.endsWith(".md")) {
+        if (!existsSync(src))
+            return "prd";
+        const content = readFileSync(src, "utf8");
+        if (TICKMARKR_NATIVE_MARKER.test(content))
+            return "native";
+        return "prd";
+    }
     return null;
 }
 export function compileSource(src, type, root) {

package/dist/compile/native.d.ts

@@ -1,4 +1,6 @@
 import { type RunGraph } from "../graph/schema.js";
+export declare const LEGACY_PREFIX: string;
+export declare const TICKMARKR_NATIVE_MARKER: RegExp;
 export declare const NATIVE_MARKER: RegExp;
 export declare function compileNative(file: string): RunGraph;
 export declare function specTemplate(): string;

package/dist/compile/native.js

@@ -1,7 +1,9 @@
 import { existsSync, readFileSync } from "node:fs";
 import { GATE_NAMES, ORACLES, SHAPES, TIERS, validateGraph } from "../graph/schema.js";
 import { CompileError, inferShape, sha256 } from "./common.js";
-export const NATIVE_MARKER = /^<!--\s*(?:tickmarkr|drovr):spec(?:\s+v1)?\s*-->\s*$/m;
+export const LEGACY_PREFIX = ["dro", "vr"].join("");
+export const TICKMARKR_NATIVE_MARKER = /^<!--\s*tickmarkr:spec(?:\s+v1)?\s*-->\s*$/m;
+export const NATIVE_MARKER = new RegExp(`^<!--\\s*(?:tickmarkr|${LEGACY_PREFIX}):spec(?:\\s+v1)?\\s*-->\\s*$`, "m");
 const HEAD_RE = /^## (T\d+):\s*(.+)$/;
 const FIELD_RE = /^- (\w+):\s*(.*)$/;
 const NESTED_RE = /^\s+- (.+)$/;
@@ -139,7 +141,7 @@ export function compileNative(file) {
     }
     return result;
 }
-// Commented native spec written to drovr.spec.md by `drovr init`. Documented via HTML comments (which the
+// Commented native spec written to tickmarkr.spec.md by `tickmarkr init`. Documented via HTML comments (which the
 // parser ignores) so the template itself round-trips through compileSource() unchanged. Every field is
 // documented; the two example tasks illustrate plain vs deps+routing-hint, each with acceptance[].
 export function specTemplate() {

package/dist/config/config.d.ts

@@ -46,7 +46,7 @@ export declare const SubPricingSchema: z.ZodObject<{
     windowsPerMonthHigh: z.ZodNumber;
 }, z.core.$strip>;
 export type SubPricing = z.infer<typeof SubPricingSchema>;
-export declare const DrovrConfigSchema: z.ZodObject<{
+export declare const TickmarkrConfigSchema: z.ZodObject<{
     concurrency: z.ZodNumber;
     driver: z.ZodEnum<{
         auto: "auto";
@@ -171,23 +171,23 @@ export declare const DrovrConfigSchema: z.ZodObject<{
         workersPerTab: z.ZodNumber;
     }, z.core.$strip>;
 }, z.core.$strip>;
-export type DrovrConfig = z.infer<typeof DrovrConfigSchema>;
+export type TickmarkrConfig = z.infer<typeof TickmarkrConfigSchema>;
 export declare class ConfigError extends Error {
     constructor(message: string);
 }
-export declare const DEFAULT_CONFIG: DrovrConfig;
+export declare const DEFAULT_CONFIG: TickmarkrConfig;
 export declare function globalConfigDir(): string;
 export declare function overlayPreferShapes(repoRoot: string, opts?: {
     globalDir?: string;
 }): ReadonlySet<string>;
 export declare function loadConfig(repoRoot: string, opts?: {
     globalDir?: string;
-}): DrovrConfig;
+}): TickmarkrConfig;
 export type InitConfigOverlay = {
     concurrency?: number;
-    driver?: DrovrConfig["driver"];
+    driver?: TickmarkrConfig["driver"];
     visibility?: {
-        llm?: DrovrConfig["visibility"]["llm"];
+        llm?: TickmarkrConfig["visibility"]["llm"];
     };
 };
 export declare function configTemplate(overlay?: InitConfigOverlay): string;

package/dist/config/config.js

@@ -63,7 +63,7 @@ const ShapeGateParticipationSchema = z
         });
     }
 });
-export const DrovrConfigSchema = z.object({
+export const TickmarkrConfigSchema = z.object({
     concurrency: z.number().int().positive(),
     driver: z.enum(["auto", "herdr", "subprocess"]),
     integrationBranchPrefix: z
@@ -92,7 +92,7 @@ export const DrovrConfigSchema = z.object({
     tiers: z.record(z.string(), TierEntrySchema),
     pricing: z.record(z.string(), z.number()),
     // v1.20 REC-02: optional detailed price table for cost estimation. Distinct from `pricing` above
-    // (the coarse per-task tier estimate `drovr plan` shows) — this one drives the usage/cost report.
+    // (the coarse per-task tier estimate `tickmarkr plan` shows) — this one drives the usage/cost report.
     // Absent ⇒ every channel reports "not measurable" (never $0). models keyed by model id (LiteLLM
     // convention); subs keyed by adapter id (subscription plans are per-account, not per-token).
     cost: z
@@ -136,7 +136,7 @@ export class ConfigError extends Error {
 export const DEFAULT_CONFIG = {
     concurrency: 3,
     driver: "auto",
-    integrationBranchPrefix: "drovr/",
+    integrationBranchPrefix: "tickmarkr/",
     taskTimeoutMinutes: 30,
     contextWarnTokens: 170_000, // v1.23 T2: overseer ctx-watch.sh proven threshold
     routing: {
@@ -154,11 +154,11 @@ export const DEFAULT_CONFIG = {
         },
         // ROUTE-14 (2026-07-11, operator-adopted): learned reordering ON by default. Shipped OFF through v1.6/v1.7
         // as a preview-then-adopt trust ramp (ROUTE-09); the operator adopts it here after v1.8 made learning
-        // auditable (VIS-05 `drovr report` learning section) and matured (decay ROUTE-11, scored utilization
+        // auditable (VIS-05 `tickmarkr report` learning section) and matured (decay ROUTE-11, scored utilization
         // ROUTE-12, escalation tiebreak ROUTE-13). SAFE BY CONSTRUCTION: an empty/cold profile ⇒ every
         // learnedScore returns exactly NEUTRAL ⇒ byte-identical v1.5 static routing, so ON only changes routing in
         // a workspace that has accumulated ≥MIN_SAMPLES warm telemetry per cell. Preview any workspace's effect
-        // first with `drovr plan` / `drovr report`; flip to "off" to pin exact static routing (the kill switch stands).
+        // first with `tickmarkr plan` / `tickmarkr report`; flip to "off" to pin exact static routing (the kill switch stands).
         learned: "on",
     },
     // Seed table (spec §13). New models = edit this (or your config.yaml), never code.
@@ -185,12 +185,17 @@ export const DEFAULT_CONFIG = {
         // promoted from overlay 2026-07-11 (MODEL-10).
         // grok-4.5-fast → cheap: speed-optimized variant, no independent benchmark scores yet → floor tier.
         // RETIRED 2026-07-13: cursor-agent seeds grok-4.5-xhigh / grok-4.5-fast-xhigh — CLI no longer reports
-        // either id (drovr plan lint, 2026-07-13). Tombstoned here; re-seed if cursor re-exposes them.
+        // either id (tickmarkr plan lint, 2026-07-13). Tombstoned here; re-seed if cursor re-exposes them.
         // (Benchmark provenance above still informs the native grok adapter seeds below.)
         "cursor-agent": {
             vendor: "cursor", channel: "sub",
             models: {
                 "composer-2.5": "mid",
+                // composer-2.5-fast → cheap: speed-optimized variant, no independent benchmark scores yet → floor
+                // tier (same policy call as grok-composer-2.5-fast below). Id live-verified in doctor.json probe
+                // 2026-07-16 (cursor-agent 2026.07.09); gives cursor a cheap-tier channel so low-complexity shapes
+                // stop burning its mid. Operator-approved 2026-07-16.
+                "composer-2.5-fast": "cheap",
             },
         },
         // GLM-5.2 → mid per benchmark policy (2026-07): SWE-bench Pro 62.1 (> GPT-5.5 58.6), FrontierSWE 74.4 ≈ Opus 4.8;
@@ -255,12 +260,8 @@ function readYaml(path) {
     return parse(readFileSync(path, "utf8"));
 }
 export function globalConfigDir() {
-    // read-old/write-new (operator-ordered rename 2026-07-15): prefer ~/.config/tickmarkr; an
-    // existing ~/.config/drovr keeps working until the operator moves it. New scaffolds use tickmarkr.
     const base = process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
-    const next = join(base, "tickmarkr");
-    const legacy = join(base, "drovr");
-    return existsSync(join(next, "config.yaml")) || !existsSync(join(legacy, "config.yaml")) ? next : legacy;
+    return join(base, "tickmarkr");
 }
 export function overlayPreferShapes(repoRoot, opts = {}) {
     const shapes = new Set();
@@ -279,7 +280,7 @@ export function loadConfig(repoRoot, opts = {}) {
     const globalCfg = readYaml(join(opts.globalDir ?? globalConfigDir(), "config.yaml"));
     const repoCfg = readYaml(join(repoRoot, stateDirName(repoRoot), "config.yaml"));
     const merged = deepMerge(deepMerge(structuredClone(DEFAULT_CONFIG), globalCfg), repoCfg);
-    const r = DrovrConfigSchema.safeParse(merged);
+    const r = TickmarkrConfigSchema.safeParse(merged);
     if (!r.success)
         throw new ConfigError(z.prettifyError(r.error));
     return r.data;