tickmarkr 1.33.0 → 1.33.1

package/README.md

@@ -62,9 +62,15 @@ npm i -g tickmarkr
 ```
 
 This installs two identical bins: `tickmarkr` and its short alias `tkr` — use whichever you
-prefer, every example below works with either. Requirements: Node ≥ 20, git, and at least one
-agent CLI on PATH (`claude`, `codex`, `cursor-agent`, `opencode`, `grok`, or `pi`) authenticated
-through its own login.
+prefer, every example below works with either.
+
+**Requirements:**
+
+- **macOS or Linux.** Every command shells out through `bash`, so native Windows is not
+  supported — use WSL (untested).
+- Node ≥ 20 and `git` on PATH.
+- At least one agent CLI on PATH (`claude`, `codex`, `cursor-agent`, `opencode`, `grok`, or
+  `pi`), authenticated through its own login. tickmarkr never handles vendor API keys itself.
 
 Then verify your fleet:
 
@@ -72,12 +78,17 @@ Then verify your fleet:
 tickmarkr doctor   # probes installed adapters, herdr, auth; prints the capability matrix
 ```
 
+**Expect `doctor` (and `init`, which runs it) to take a while on first run:** auth detection is
+one real, short LLM call per configured model per installed CLI — honest, but not instant. A
+machine with three CLIs and several models each can take a minute or more; each probe is capped
+at 30s.
+
 ## Quickstart (5 minutes)
 
 ```bash
-tickmarkr init                 # guided setup + doctor; scaffolds .drovr/config.yaml and drovr.spec.md
-# edit drovr.spec.md            # the native spec template, marked <!-- drovr:spec -->
-tickmarkr compile drovr.spec.md # spec → .drovr/graph.json (fails without acceptance criteria)
+tickmarkr init                 # guided setup + doctor; scaffolds .drovr/config.yaml and tickmarkr.spec.md
+# edit tickmarkr.spec.md        # the native spec template, marked <!-- drovr:spec -->
+tickmarkr compile tickmarkr.spec.md # spec → .drovr/graph.json (fails without acceptance criteria)
 tickmarkr plan                 # dry-run routing table + cost estimate + floor lints
 tickmarkr run                  # execute the graph (--concurrency N --driver herdr|subprocess --route-strict)
 tickmarkr report <runId> --md  # engagement record in Markdown
@@ -312,11 +323,11 @@ produced the graph. Upstream, these front-ends exist:
 
 | Spec source | Support | How |
 |---|---|---|
-| **drovr spec** (native format) | Native/default | `tickmarkr init` template with the `<!-- drovr:spec -->` marker |
+| **tickmarkr spec** (native format) | Native/default | `tickmarkr init` template with the `<!-- drovr:spec -->` marker |
 | **Spec Kit** feature dir | Native | dir containing `tasks.md` |
 | **GSD** phase dir | Native | dir containing `*-PLAN.md` |
 | **Markdown PRD** | Native (universal adapter) | any `.md` with tasks + acceptance criteria |
-| OpenSpec, BMAD, Superpowers, others | Not yet | render to a drovr spec (the `<!-- drovr:spec -->` marker plus the full Task surface), or contribute a front-end: one parser module behind `src/compile/index.ts`, same pattern as `gsd.ts` |
+| OpenSpec, BMAD, Superpowers, others | Not yet | render to a tickmarkr spec (the `<!-- drovr:spec -->` marker plus the full Task surface), or contribute a front-end: one parser module behind `src/compile/index.ts`, same pattern as `gsd.ts` |
 
 Compile fails loudly on anything it can't recognize (`--type native|speckit|prd|gsd` to force).
 
@@ -353,8 +364,8 @@ Untyped acceptance strings in existing specs compile as `oracle: judge` + warnin
 
 Cloning this repo gives Claude Code project skills under `.claude/skills/`:
 
-- **`/drovr-loop`** — the SDD-agnostic loop: compile one spec, read the plan, run from the journal, merge green work, and commit only the Markdown execution record beside that spec. For GSD bookkeeping, use `/drovr-auto`.
-- **`/drovr-auto`** — the **GSD binding**: run remaining GSD milestone phases autonomously with tickmarkr as the
+- **`/tickmarkr-loop`** — the SDD-agnostic loop: compile one spec, read the plan, run from the journal, merge green work, and commit only the Markdown execution record beside that spec. For GSD bookkeeping, use `/tickmarkr-auto`.
+- **`/tickmarkr-auto`** — the **GSD binding**: run remaining GSD milestone phases autonomously with tickmarkr as the
   executor (plans → compile → dry-run → run → merge → sync-back). Bindings are per-SDD by nature — the
   sync-back writes that methodology's artifacts; other SDDs need their own thin binding, not this one.
 - **`/overseer`** — supervise an autonomous tickmarkr engagement from a Herdr workspace: two-tier visible hierarchy,

package/dist/adapters/cursor-agent.js

@@ -49,7 +49,7 @@ export const cursorAgent = {
     // print-only). Doctor names the dialog; the daemon auto-answers it via trustDialog once per slot.
     trust: () => ({
         status: "action-required",
-        command: 'accept the cursor-agent "Workspace Trust Required" dialog (Enter) — drovr auto-answers once per slot',
+        command: 'accept the cursor-agent "Workspace Trust Required" dialog (Enter) — tickmarkr auto-answers once per slot',
     }),
     trustDialog: CURSOR_TRUST_DIALOG,
     // v1.5 MODEL-01: fail OPEN to [] (advisory detection, unlike gates). --list-models may touch the

package/dist/adapters/model-lints.js

@@ -1,7 +1,7 @@
 import { MODEL_ID_RE } from "./types.js";
 // date the tiers seeds were last live-verified (Phase 6/7 reseed) — surfaced when an adapter has no list surface.
 export const SEED_STAMPED = "2026-07-09";
-// knowledge past this age gets a "rerun drovr doctor" nudge (BLOCKED_POLL_MS-style named constant).
+// knowledge past this age gets a "rerun tickmarkr doctor" nudge (BLOCKED_POLL_MS-style named constant).
 export const MODEL_STALE_DAYS = 30;
 const DAY_MS = 86400000;
 // cursor-agent 2026.07.08 reports 193 mostly-parameterized ids (e.g. gpt-5.3-codex-high-fast); filter the `auto`
@@ -26,7 +26,7 @@ export function modelLints(cfg, health, adapters) {
         const detected = h?.models ?? []; // MANDATORY default: pre-v1.5 files lack a populated models array
         if (detected.length === 0) {
             if (h?.installed)
-                lints.push(`${id}: no detection data — run drovr doctor`);
+                lints.push(`${id}: no detection data — run tickmarkr doctor`);
             continue; // no data to diff or age
         }
         const configured = Object.keys(cfg.tiers[id].models);
@@ -45,7 +45,7 @@ export function modelLints(cfg, health, adapters) {
         if (at) {
             const days = Math.floor((Date.now() - Date.parse(at)) / DAY_MS); // completed days — never overstate age
             if (days >= MODEL_STALE_DAYS)
-                lints.push(`${id}: model knowledge is ${days} days old — rerun drovr doctor`);
+                lints.push(`${id}: model knowledge is ${days} days old — rerun tickmarkr doctor`);
         }
     }
     return lints;

package/dist/adapters/prompt.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { renderAcceptanceItem } from "../graph/schema.js";
 export function buildTaskPrompt(task, feedback = "", nonce = "") {
     const list = (xs) => xs.map((x) => `- ${x}`).join("\n");
-    return `You are an autonomous coding worker dispatched by drovr into an isolated git worktree.
+    return `You are an autonomous coding worker dispatched by tickmarkr into an isolated git worktree.
 
 ## Task ${task.id}: ${task.title}
 Goal: ${task.goal}

package/dist/cli/commands/approve.js

@@ -40,7 +40,7 @@ export async function approve(argv, cwd = process.cwd()) {
         via: "cli",
         ...(capPark ? { release: ATTEMPT_CAP_RELEASE } : {}),
     });
-    return `approved ${taskId} in ${runId} — by ${by}; run \`drovr resume ${runId}\` to dispatch it`;
+    return `approved ${taskId} in ${runId} — by ${by}; run \`tickmarkr resume ${runId}\` to dispatch it`;
 }
 // hand-parsed argv — no CLI framework (house style). Flags --by <name> and --reason <text>; positionals
 // are runId then taskId. Throws usage on missing positionals (mirrors resume.ts/unlock.ts).
@@ -53,12 +53,12 @@ function parseArgs(argv) {
         if (a === "--by") {
             by = argv[++i];
             if (!by)
-                throw new Error("usage: drovr approve <run-id> <task-id> [--by <name>] [--reason <text>]");
+                throw new Error("usage: tickmarkr approve <run-id> <task-id> [--by <name>] [--reason <text>]");
         }
         else if (a === "--reason") {
             reason = argv[++i];
             if (!reason)
-                throw new Error("usage: drovr approve <run-id> <task-id> [--by <name>] [--reason <text>]");
+                throw new Error("usage: tickmarkr approve <run-id> <task-id> [--by <name>] [--reason <text>]");
         }
         else {
             positionals.push(a);
@@ -66,7 +66,7 @@ function parseArgs(argv) {
     }
     const [runId, taskId] = positionals;
     if (!runId || !taskId) {
-        throw new Error("usage: drovr approve <run-id> <task-id> [--by <name>] [--reason <text>]");
+        throw new Error("usage: tickmarkr approve <run-id> <task-id> [--by <name>] [--reason <text>]");
     }
     return { runId, taskId, by: by ?? userInfo().username, reason };
 }

package/dist/cli/commands/compile.js

@@ -11,7 +11,7 @@ export async function compile(argv, cwd = process.cwd()) {
     });
     const src = positionals[0];
     if (!src)
-        throw new Error("usage: drovr compile <spec-dir-or-md> [--type speckit|prd|gsd|native]");
+        throw new Error("usage: tickmarkr compile <spec-dir-or-md> [--type speckit|prd|gsd|native]");
     // resolve against the target repo, not the process cwd (the CLI test passes a tmp repo)
     const g = compileSource(isAbsolute(src) ? src : join(cwd, src), values.type, cwd);
     // HARD-01: a compile clobbering a running daemon's graph.json is the same last-write-wins race

package/dist/cli/commands/doctor.js

@@ -1,10 +1,40 @@
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { allAdapters, probeAll, probeModels, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
+import { drovrDir } from "../../graph/graph.js";
 import { modelLints, suggestOverlay } from "../../adapters/model-lints.js";
 import { loadConfig } from "../../config/config.js";
 import { HerdrDriver } from "../../drivers/herdr.js";
 import { disallowedBy, excludedChannels, exclusionLine, preferRanks } from "../../route/preference.js";
+// same gate + palette as status's audit-ledger frame: styled only on a real TTY, plain otherwise
+const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
+const color = (text, code) => `\x1b[${code}m${text}\x1b[0m`;
+// TTY-only line pass: color the verdict symbols, dim the chrome (section titles, parentheticals,
+// n/a rows). Padding is untouched — every rewrite swaps equal-width text or wraps it in ANSI.
+function stylize(out) {
+    if (!visual())
+        return out;
+    const rule = color("─".repeat(Math.min(process.stdout.columns ?? 80, 100)), 2);
+    return out.split("\n").map((line) => {
+        if (line.startsWith("tickmarkr doctor"))
+            return ` ${color("✓", 32)} ${color("tickmarkr", 1)} doctor ${color("· capability matrix", 2)}\n${rule}`;
+        if (/^(workspace trust|model status|model drift)/.test(line))
+            return color(line, 2);
+        return line
+            .replace(/^(\s+)✓ /, (_, s) => `${s}${color("✓", 32)} `)
+            .replace(/^(\s+)✗ /, (_, s) => `${s}${color("✗", 31)} `)
+            .replace(/^(\s+)! /, (_, s) => `${s}${color("!", 33)} `)
+            .replace(/^(\s+)= (.*)$/, (_, s, rest) => `${s}${color(`= ${rest}`, 2)}`)
+            .replace(/(\(auth assumed; verified at dispatch \(failover on auth\/quota errors\)\))/, (m) => color(m, 2))
+            .replace(/\bauthed\b(?!:)/, color("authed", 32))
+            .replace(/\bunauthed:/, color("unauthed:", 33));
+    }).join("\n");
+}
 export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters()) {
     const cfg = loadConfig(cwd);
+    // stderr, live: auth probes are real LLM calls (up to 30s per configured model) and the CLI
+    // otherwise prints nothing until the end — silence here reads as a hang (v1.33.1)
+    console.error("probing installed agent CLIs — one short LLM call per configured model, may take a minute...");
     const health = await probeAll(adapters);
     // MODEL-02: detect models where the adapter exposes a list surface, BEFORE writing doctor.json (write once, below).
     // Fail OPEN — the inverse of gates' fail-closed: detection is advisory, so a broken list surface NEVER fails doctor.
@@ -67,8 +97,20 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     if (servable.length)
         rows.push(`  ! ${servabilityLine(servable)}`);
     // MODEL-05/06: print-only drift fragment; advisory, whole-line-commented additions, drovr 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);
-    const drift = frag ? `\nmodel drift — paste-ready overlay (advisory; tickmarkr never applies):\n${frag}` : "";
+    let drift = "";
+    if (frag) {
+        if (visual()) {
+            const overlayPath = join(drovrDir(cwd), "doctor-overlay.yaml");
+            writeFileSync(overlayPath, frag);
+            drift = `\nmodel drift: unclassified models detected — paste-ready overlay written to ${overlayPath} (advisory; tickmarkr never applies it)`;
+        }
+        else {
+            drift = `\nmodel drift — paste-ready overlay (advisory; tickmarkr never applies):\n${frag}`;
+        }
+    }
     // T4: model-status table — one row per CLASSIFIED model (tiers config) with tier, auth verdict
     // (reason + date when unauthed), operator-deny flag, and prefer rank across the routing map.
     // Unclassified listed models (detected via listModels but never tiered) compress to one count line
@@ -99,5 +141,5 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
         return rows;
     });
     const modelSummary = modelStatus.length ? `\nmodel status:\n${modelStatus.join("\n")}` : "";
-    return `tickmarkr doctor — capability matrix:\n${rows.join("\n")}${modelSummary}${drift}\nwrote .drovr/doctor.json`;
+    return stylize(`tickmarkr doctor — capability matrix:\n${rows.join("\n")}${modelSummary}${drift}\nwrote .drovr/doctor.json`);
 }

package/dist/cli/commands/plan.js

@@ -21,7 +21,7 @@ export async function plan(_argv, cwd = process.cwd(), adapters = allAdapters())
     // output byte-identical to today.
     const profile = loadRoutingProfile(cwd, cfg, { preview: true });
     let deviations = 0;
-    const lines = [`drovr plan — dry run (${channels.length} channels available)`, ""];
+    const lines = [`tickmarkr plan — dry run (${channels.length} channels available)`, ""];
     const excluded = excludedChannels(cfg, adapters, health);
     if (excluded.length)
         lines.push(exclusionLine(excluded), "");
@@ -38,7 +38,7 @@ export async function plan(_argv, cwd = process.cwd(), adapters = allAdapters())
     if (cached) {
         const age = doctorAgeMs(cwd);
         if (age !== null && age > DOCTOR_STALE_MS) {
-            lines.push(`doctor.json is ${Math.floor(age / 3_600_000)}h old — run 'drovr doctor' to refresh (servability/auth may have changed)`, "");
+            lines.push(`doctor.json is ${Math.floor(age / 3_600_000)}h old — run 'tickmarkr doctor' to refresh (servability/auth may have changed)`, "");
         }
     }
     // HYG-07(a)/T2 pin honesty: append the drop reason when a pin/miss message names a filtered channel —

package/dist/cli/commands/profile.js

@@ -32,7 +32,7 @@ function show(cwd) {
     const cursor = readProfileCursor(cwd);
     const p = loadRoutingProfile(cwd, cfg, { preview: true });
     const header = [
-        `drovr profile`,
+        `tickmarkr profile`,
         `  routing.learned: ${cfg.routing.learned}${cfg.routing.learned === "off" ? " (preview — routing is inert)" : ""}`,
         `  runs window: ${RUNS_WINDOW}`,
         ...(cursor ? [`  reset cursor: ${cursor}`] : []),

package/dist/cli/commands/report.js

@@ -293,9 +293,9 @@ export async function report(argv, cwd = process.cwd()) {
         options: { md: { type: "boolean" } },
         allowPositionals: true,
     });
-    const runId = positionals[0] ?? Journal.latestRunId(cwd);
+    const runId = positionals[0] ?? Journal.latestRunId(cwd, { withJournal: true });
     if (!runId)
-        throw new Error("no runs found — usage: drovr report <run-id> [--md]");
+        throw new Error("no runs found — usage: tickmarkr report <run-id> [--md]");
     const j = Journal.open(cwd, runId);
     const events = j.read();
     if (values.md) {

package/dist/cli/commands/resume.js

@@ -5,7 +5,7 @@ import { formatJournalNarration } from "../../run/journal.js";
 export async function resume(argv, cwd = process.cwd()) {
     const runId = argv[0];
     if (!runId)
-        throw new Error("usage: drovr resume <run-id>");
+        throw new Error("usage: tickmarkr resume <run-id>");
     const s = await runDaemon(cwd, { runId, resume: true, driver: pickDriver(loadConfig(cwd)), narrate: (event) => console.log(formatJournalNarration(event)) });
     return `resumed ${s.runId} — ${formatSummary(s)}`;
 }

package/dist/cli/commands/scope.js

@@ -10,7 +10,7 @@ export async function scope(argv, cwd = process.cwd(), adapters = allAdapters(),
         allowPositionals: true,
     });
     if (positionals.length !== 1)
-        throw new Error("usage: drovr scope <intent-file> [--force]");
+        throw new Error("usage: tickmarkr scope <intent-file> [--force]");
     const source = positionals[0];
     const intentFile = isAbsolute(source) ? source : join(cwd, source);
     const result = await scopeIntent(intentFile, cwd, {

package/dist/cli/commands/status.js

@@ -39,21 +39,28 @@ const gateBox = (state, unicode) => {
         return state === "pass" ? "✓" : state === "fail" ? "✗" : state === "skip" ? "·" : "☐";
     return state === "pass" ? "[x]" : state === "fail" ? "[!]" : state === "skip" ? "." : "[ ]";
 };
-const gateChain = (task, events, unicode) => {
+const gateStates = (task, events) => {
     const outcomes = new Map();
     const start = attemptStartIdx(events, task.id);
     if (start >= 0) {
         for (const e of events.slice(start)) {
             if (e.taskId !== task.id || e.event !== "gate-result" || typeof e.data.gate !== "string")
                 continue;
-            if (e.data.pass === true)
+            if (e.data.skipped === true)
+                outcomes.set(e.data.gate, "skip");
+            else if (e.data.pass === true)
                 outcomes.set(e.data.gate, "pass");
             else if (e.data.pass === false)
                 outcomes.set(e.data.gate, "fail");
         }
     }
-    return GATE_NAMES.map((gate) => `${GATE_KEYS[gate]}${gateBox(task.gates.includes(gate) ? outcomes.get(gate) ?? "open" : "skip", unicode)}`).join(" ");
+    return GATE_NAMES.map((gate) => task.gates.includes(gate) ? outcomes.get(gate) ?? "open" : "skip");
 };
+// verdict semantics only: pass green, fail red, skip/open dim chrome — everything else stays quiet
+const GATE_STATE_COLOR = { pass: 32, fail: 31, skip: 2, open: 2 };
+const gateChain = (states, unicode) => GATE_NAMES.map((gate, i) => color(`${GATE_KEYS[gate]}${gateBox(states[i], unicode)}`, GATE_STATE_COLOR[states[i]], unicode)).join(" ");
+// plain (uncolored) chip width for column math — ANSI codes have zero display width
+const gateChainWidth = (unicode) => GATE_NAMES.reduce((w, gate) => w + GATE_KEYS[gate].length + (unicode ? 1 : 3) + 1, -1);
 const shortGoal = (goal, max) => {
     const clause = goal.split(/[,;.?!]/, 1)[0].trim();
     if (clause.length <= max)
@@ -105,7 +112,7 @@ const liveness = (events) => {
 };
 const renderFrame = (cwd) => {
     const g = loadGraph(cwd);
-    const runId = Journal.latestRunId(cwd);
+    const runId = Journal.latestRunId(cwd, { withJournal: true });
     const assignments = new Map();
     let replayed = null;
     let events = [];
@@ -130,24 +137,63 @@ const renderFrame = (cwd) => {
     const waiting = new Set(pendingTasks(effective).map((t) => t.id));
     const unicode = visual();
     const divider = unicode ? " · " : " / ";
-    const rows = g.tasks.map((t) => {
+    const width = process.stdout.columns ?? 120;
+    const done = effective.tasks.filter((t) => t.status === "done").length;
+    const cells = g.tasks.map((t) => {
         const st = replayed?.get(t.id) ?? t.status;
         const label = starved.has(t.id) ? " starved" : waiting.has(t.id) ? " dep-waiting" : "";
         const channel = assignments.get(t.id) ?? "-";
         const assignCol = contexts.has(t.id) ? `${channel}${divider}ctx ${contexts.get(t.id)}` : channel;
-        const chain = gateChain(t, events, unicode);
-        const statusText = color(String(st), st === "done" ? 32 : st === "failed" ? 31 : st === "human" ? 33 : 36, unicode);
-        const suffix = `  ${chain}  ${String(st)}${label}  ${assignCol}`;
-        const width = process.stdout.columns ?? 120;
-        const prefix = `  ${taskBox(st, unicode)} ${t.id} `;
-        return `${prefix}${shortGoal(t.goal, Math.max(0, width - prefix.length - suffix.length))}  ${chain}  ${statusText}${label}  ${assignCol}`;
+        return { t, st, label, assignCol, states: gateStates(t, events) };
     });
-    const done = effective.tasks.filter((t) => t.status === "done").length;
-    const header = runId
-        ? `tickmarkr status${divider}run ${runId}${divider}${liveness(events).replaceAll(" · ", divider)}${divider}${done}/${g.tasks.length} done`
-        : `tickmarkr status${divider}no runs yet${divider}${done}/${g.tasks.length} done`;
-    const legend = `  gates: ${GATE_NAMES.map((gate) => `${GATE_KEYS[gate]} ${gate}`).join(divider)}`;
-    return [header, legend, ...rows].join("\n");
+    const statusColor = (st) => st === "done" ? 32 : st === "failed" ? 31 : st === "human" ? 33 : 36;
+    if (!unicode) {
+        // machine/CI surface — layout unchanged (pipes, greps, and the golden pins depend on it)
+        const rows = cells.map(({ t, st, label, assignCol, states }) => {
+            const chain = gateChain(states, false);
+            const prefix = `  ${taskBox(st, false)} ${t.id} `;
+            const suffix = `  ${chain}  ${String(st)}${label}  ${assignCol}`;
+            return `${prefix}${shortGoal(t.goal, Math.max(0, width - prefix.length - suffix.length))}${suffix}`;
+        });
+        const header = runId
+            ? `tickmarkr status${divider}run ${runId}${divider}${liveness(events).replaceAll(" · ", divider)}${divider}${done}/${g.tasks.length} done`
+            : `tickmarkr status${divider}no runs yet${divider}${done}/${g.tasks.length} done`;
+        const legend = `  gates: ${GATE_NAMES.map((gate) => `${GATE_KEYS[gate]} ${gate}`).join(divider)}`;
+        return [header, legend, ...rows].join("\n");
+    }
+    // TTY: audit-ledger frame — bold brand mark, dim chrome, semantic color only on verdicts,
+    // completion gauge, and column-aligned rows (pad plain text FIRST, colorize after: ANSI has
+    // zero display width and would corrupt padEnd math)
+    const dim = (s) => color(s, 2, true);
+    const dot = dim(" · ");
+    const anyFailed = cells.some((c) => c.st === "failed");
+    const gaugeCells = 10;
+    const fill = g.tasks.length ? Math.round((done / g.tasks.length) * gaugeCells) : 0;
+    const gauge = (fill ? color("█".repeat(fill), anyFailed ? 31 : 32, true) : "") + (fill < gaugeCells ? dim("░".repeat(gaugeCells - fill)) : "");
+    const live = liveness(events)
+        .replace(/\bdead\b/, color("dead", 31, true))
+        .replace(/\balive\b/, color("alive", 32, true))
+        .replaceAll(" · ", dot);
+    const tally = `${done}/${g.tasks.length} done`;
+    const header = ` ${color("✓", 32, true)} ${color("tickmarkr", 1, true)}${dot}` +
+        (runId ? `run ${runId}${dot}${live}${dot}` : `no runs yet${dot}`) +
+        `${gauge} ${done === g.tasks.length && g.tasks.length > 0 ? color(tally, 32, true) : tally}`;
+    const rule = dim("─".repeat(Math.min(width, 100)));
+    const legend = dim(`   gates: ${GATE_NAMES.map((gate) => `${GATE_KEYS[gate]} ${gate}`).join(" · ")}`);
+    const idW = Math.max(...cells.map((c) => c.t.id.length), 2);
+    const stW = Math.max(...cells.map((c) => (String(c.st) + c.label).length));
+    const chainW = gateChainWidth(true);
+    const assignW = Math.max(...cells.map((c) => c.assignCol.length));
+    const goalW = Math.max(8, width - (5 + idW) - 2 - chainW - 2 - stW - 2 - assignW);
+    const rows = cells.map(({ t, st, label, assignCol, states }) => {
+        const box = color(taskBox(st, true), st === "done" ? 32 : st === "failed" ? 31 : st === "human" ? 33 : 2, true);
+        const goal = shortGoal(t.goal, goalW).padEnd(goalW);
+        const statusCell = color(String(st), statusColor(st), true) +
+            (label ? (label === " starved" ? color(label, 31, true) : dim(label)) : "") +
+            " ".repeat(stW - (String(st) + label).length);
+        return `  ${box} ${t.id.padEnd(idW)} ${goal}  ${gateChain(states, true)}  ${statusCell}  ${dim(assignCol)}`;
+    });
+    return [header, rule, legend, ...rows].join("\n");
 };
 export async function status(argv, cwd = process.cwd(), opts = {}) {
     if (!argv.includes("--watch"))
@@ -161,7 +207,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}`);
+            process.stdout.write(`\x1b[2J\x1b[H${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/compile/gsd.js

@@ -92,7 +92,7 @@ function compileOne(file, storedPath) {
     const truths = strings(fm.must_haves?.truths);
     const acceptance = [...dones, ...truths].filter(Boolean);
     if (!acceptance.length) {
-        throw new CompileError(`${file} has no acceptance criteria — every drovr task needs them.\n` +
+        throw new CompileError(`${file} has no acceptance criteria — every tickmarkr task needs them.\n` +
             `GSD source: add <done> lines to the plan's tasks, or must_haves.truths in its frontmatter.`);
     }
     // @-refs from the <context> block only; keep repo-relative paths (no $VAR, ~, absolute, or ..-escape)
@@ -151,7 +151,7 @@ function compileOne(file, storedPath) {
 }
 export function compileGsd(src, root) {
     if (!existsSync(src))
-        throw new CompileError(`${src} does not exist — point drovr compile at a GSD phase directory or a *-PLAN.md`);
+        throw new CompileError(`${src} does not exist — point tickmarkr compile at a GSD phase directory or a *-PLAN.md`);
     const isDir = statSync(src).isDirectory();
     const files = isDir
         ? readdirSync(src)
@@ -160,7 +160,7 @@ export function compileGsd(src, root) {
             .map((f) => join(src, f))
         : [src];
     if (!files.length) {
-        throw new CompileError(`no *-PLAN.md files in ${src} — point drovr compile at a GSD phase directory`);
+        throw new CompileError(`no *-PLAN.md files in ${src} — point tickmarkr compile at a GSD phase directory`);
     }
     // context[0] must be readable from an isolated worktree: store repo-relative, never absolute
     const rel = (f) => {

package/dist/compile/native.js

@@ -135,7 +135,7 @@ export function compileNative(file) {
     // v1.19 read-old/write-new: a plain-string acceptance item compiles as a judge oracle. This is the
     // one-time nudge toward typed oracles (command/test/judge); PRD/Spec Kit/GSD stay silent (untouched).
     if (plainCount > 0) {
-        console.warn(`drovr: ${plainCount} acceptance item${plainCount === 1 ? "" : "s"} in ${file} ${plainCount === 1 ? "is a plain string" : "are plain strings"} — compiled as judge oracle${plainCount === 1 ? "" : "s"}. Prefix with command:/test:/judge: to make the oracle explicit.`);
+        console.warn(`tickmarkr: ${plainCount} acceptance item${plainCount === 1 ? "" : "s"} in ${file} ${plainCount === 1 ? "is a plain string" : "are plain strings"} — compiled as judge oracle${plainCount === 1 ? "" : "s"}. Prefix with command:/test:/judge: to make the oracle explicit.`);
     }
     return result;
 }
@@ -144,10 +144,10 @@ export function compileNative(file) {
 // documented; the two example tasks illustrate plain vs deps+routing-hint, each with acceptance[].
 export function specTemplate() {
     return `<!-- tickmarkr:spec -->
-# drovr native spec
+# tickmarkr native spec
 
-Your starting point for a drovr native spec. Edit this file, then run:
-  drovr compile drovr.spec.md && drovr plan && drovr run
+Your starting point for a tickmarkr native spec. Edit this file, then run:
+  tickmarkr compile tickmarkr.spec.md && tickmarkr plan && tickmarkr run
 
 Each task is a "## Tn: Title" heading with "- field: value" bullets.
 acceptance is required on every task (a nested list of observable outcomes).

package/dist/compile/speckit.js

@@ -7,7 +7,7 @@ const SUB_RE = /^\s+- (\w+):\s*(.+)$/;
 export function compileSpecKit(dir) {
     const path = join(dir, "tasks.md");
     if (!existsSync(path)) {
-        throw new CompileError(`no tasks.md in ${dir} — point drovr compile at a Spec Kit feature directory`);
+        throw new CompileError(`no tasks.md in ${dir} — point tickmarkr compile at a Spec Kit feature directory`);
     }
     const content = readFileSync(path, "utf8");
     const drafts = [];

package/dist/config/config.js

@@ -269,7 +269,7 @@ export function loadConfig(repoRoot, opts = {}) {
     return r.data;
 }
 export function configTemplate() {
-    return `# drovr config overlay — merges over built-in defaults (repo beats global beats defaults)
+    return `# tickmarkr config overlay — merges over built-in defaults (repo beats global beats defaults)
 # concurrency: 3
 # driver: auto            # auto | herdr | subprocess
 # taskTimeoutMinutes: 30
@@ -279,9 +279,9 @@ export function configTemplate() {
 #   map:                  # per-shape routing; pin an exact CLI+model, or tier+prefer
 #     implement: { tier: mid, prefer: [cursor-agent, codex] }
 #     migration: { pin: { via: claude-code, model: fable } }
-#   floors:               # advisory minimum tiers; 'drovr plan' lints violations
+#   floors:               # advisory minimum tiers; 'tickmarkr plan' lints violations
 #     migration: frontier
-#   learned: on            # default ON (ROUTE-14); cold profile = exact v1.5 static routing, warms per workspace. Set 'off' to pin static routing; preview with 'drovr plan'
+#   learned: on            # default ON (ROUTE-14); cold profile = exact v1.5 static routing, warms per workspace. Set 'off' to pin static routing; preview with 'tickmarkr plan'
 #   learnedTuning: { halfLifeRuns: 5, availWeight: 0.05 }  # optional; defaults byte-identical
 #   allow: { adapters: [claude-code, codex] }   # optional fleet allowlist; presence activates even if empty (fail-closed)
 #   deny: { models: [codex:gpt-5.5] }           # optional fleet denylist; deny beats allow on conflict
@@ -321,9 +321,9 @@ export function configTemplate() {
 # dialog stalling unattended HEADLESS runs (live-verified on claude 2.1.205). Interactive TUIs still
 # show a first-entry dialog — but it is the workspace TRUST dialog, not MCP config loading (live-drilled
 # claude 2.1.206, 2026-07-10). There is NO CLI flag to pre-accept trust; the only store is claude's global
-# ~/.claude.json keyed on the EXACT worktree path. drovr does NOT write it (HYG-03 won't-fix, decision B:
+# ~/.claude.json keyed on the EXACT worktree path. tickmarkr does NOT write it (HYG-03 won't-fix, decision B:
 # claude's own last-writer-wins persistence races any seed). Cost is ~one dismissal per worktree path,
-# ever — drovr reuses stable worktree paths so the accept persists across runs; blocked-pane paging
+# ever — tickmarkr reuses stable worktree paths so the accept persists across runs; blocked-pane paging
 # surfaces each first-time dialog.
 `;
 }

package/dist/drivers/subprocess.js

@@ -57,7 +57,7 @@ export class SubprocessDriver {
         p.stdout.on("data", (d) => (s.buf = (s.buf + d).slice(-MAX_BUF)));
         p.stderr.on("data", (d) => (s.buf = (s.buf + d).slice(-MAX_BUF)));
         p.on("close", () => (s.exited = true));
-        p.on("error", (e) => { s.buf = (s.buf + `\n[drovr subprocess error] ${e}\n`).slice(-MAX_BUF); s.exited = true; });
+        p.on("error", (e) => { s.buf = (s.buf + `\n[tickmarkr subprocess error] ${e}\n`).slice(-MAX_BUF); s.exited = true; });
     }
     async waitOutput(slot, pattern, timeoutMs, opts) {
         const s = this.state(slot);
@@ -92,7 +92,7 @@ export class SubprocessDriver {
     async notify(msg, _opts) {
         if (_opts?.tier === "routine")
             return;
-        console.log(`[drovr] ${msg}`);
+        console.log(`[tickmarkr] ${msg}`);
     }
     async close(slot) {
         const s = this.slots.get(slot.id);

package/dist/gates/baseline.js

@@ -71,8 +71,12 @@ export async function compareToBaseline(cwd, commands, baseline, enabled) {
     const results = [];
     for (const name of enabled) {
         const cmd = commands[name];
-        if (!cmd)
-            continue; // nothing detected for this gate in the target repo
+        if (!cmd) {
+            // nothing detected for this gate in the target repo — journal an explicit skip instead of
+            // vanishing silently (a lint gate with no lint script rendered as forever-open in status)
+            results.push({ gate: name, pass: true, details: `no ${name} command detected — skipped`, meta: { skipped: true } });
+            continue;
+        }
         const r = await sh(cmd, cwd);
         if (r.code === 0) {
             results.push({ gate: name, pass: true, details: "exit 0" });

package/dist/graph/graph.js

@@ -24,7 +24,7 @@ export function drovrDir(repoRoot) {
 export function loadGraph(repoRoot) {
     const p = graphPath(repoRoot);
     if (!existsSync(p))
-        throw new Error(`no graph at ${p} — run \`drovr compile <src>\` first`);
+        throw new Error(`no graph at ${p} — run \`tickmarkr compile <src>\` first`);
     return validateGraph(JSON.parse(readFileSync(p, "utf8")));
 }
 export function saveGraph(repoRoot, g) {

package/dist/plan/prompt.js

@@ -1,6 +1,6 @@
 export function scopePrompt(intent, repair) {
     return `DROVR-JUDGE
-You are drafting a drovr native spec from an answered intent. Return only the Markdown spec, with no commentary or code fence.
+You are drafting a tickmarkr native spec from an answered intent. Return only the Markdown spec, with no commentary or code fence.
 
 The draft must:
 - start with <!-- tickmarkr:spec -->

package/dist/run/consult.js

@@ -6,7 +6,7 @@ import { sh } from "./git.js";
 const ACTIONS = ["retry", "reroute", "decompose", "human"];
 export function buildDossierPrompt(d) {
     return `DROVR-CONSULT
-You are a senior engineering consult for the drovr orchestrator. A worker task hit trouble.
+You are a senior engineering consult for the tickmarkr orchestrator. A worker task hit trouble.
 Read the dossier and return a verdict. Be decisive; cost is the lowest priority, quality the highest.
 
 ## Task: ${d.taskId} — trigger: ${d.trigger}

package/dist/run/daemon.js

@@ -90,7 +90,7 @@ export async function runDaemon(repoRoot, opts = {}) {
         // show. driver.narrator is undefined on subprocess → no-op (subprocess spawns nothing). Swallowed:
         // a failed-to-open or later-dead watch pane never affects the run.
         try {
-            await driver.narrator?.(repoRoot, "drovr status --watch", runId);
+            await driver.narrator?.(repoRoot, "tickmarkr status --watch", runId);
         }
         catch {
             /* cosmetic-only — the run proceeds without a live surface */
@@ -138,7 +138,7 @@ export async function runDaemon(repoRoot, opts = {}) {
         // merges are serialized — two concurrent `git merge`s in one worktree would corrupt each other
         let mergeChain = Promise.resolve();
         const mergeSerial = (taskBranch, t, gated) => {
-            const next = mergeChain.then(() => mergeTask(intWt, taskBranch, `drovr: merge ${t.id} ${t.title}`, gated));
+            const next = mergeChain.then(() => mergeTask(intWt, taskBranch, `tickmarkr: merge ${t.id} ${t.title}`, gated));
             mergeChain = next.catch(() => undefined);
             return next;
         };
@@ -152,7 +152,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 journal.telemetry({ taskId: t.id, shape: t.shape, adapter: assignment.adapter, model: assignment.model, channel: assignment.channel, attempts, outcome: "human", durationMs: Date.now() - startMs, parkKind: kind ?? undefined, gateFails, consults, tokens, meteredAttempts: tokens ? metered : undefined, retryMode });
             }
             await reconcile({ spareLiveLlm: true }); // task-human is a terminal event — sweep, sparing sibling tasks' live LLM panes
-            await driver.notify(`drovr ${runId}: ${t.id} needs a human — ${reason}`, { tier: "attention" });
+            await driver.notify(`tickmarkr ${runId}: ${t.id} needs a human — ${reason}`, { tier: "attention" });
         };
         const execTask = async (t) => {
             const startMs = Date.now();
@@ -251,7 +251,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     action: v.action, notes: v.notes,
                     ...(v.excludeAdapter ? { excludeAdapter: v.excludeAdapter } : {}),
                 });
-                await driver.notify(`drovr ${runId}: ${t.id} consult verdict: ${v.action}`, { tier: "attention" });
+                await driver.notify(`tickmarkr ${runId}: ${t.id} consult verdict: ${v.action}`, { tier: "attention" });
                 if (v.action === "retry") {
                     feedback = v.notes || feedback;
                     return true;
@@ -385,7 +385,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         threshold: cfg.contextWarnTokens,
                         attempt,
                     });
-                    await driver.notify(`drovr ${runId}: ${t.id} context ${usage.tokens} tokens ≥ ${cfg.contextWarnTokens}`, { tier: "attention" });
+                    await driver.notify(`tickmarkr ${runId}: ${t.id} context ${usage.tokens} tokens ≥ ${cfg.contextWarnTokens}`, { tier: "attention" });
                 };
                 let finished;
                 let output;
@@ -448,7 +448,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                             }
                             paged = true; // page once — the visible pane is the operator's to unblock; task timeout is the backstop
                             const why = st === "blocked" ? "is blocked on a prompt — approve in its pane" : "looks idle without finishing — check its pane";
-                            await driver.notify(`drovr ${runId}: ${slot.name} ${why}`, { tier: "attention" });
+                            await driver.notify(`tickmarkr ${runId}: ${slot.name} ${why}`, { tier: "attention" });
                         }
                         // a dead pane or a false-positive marker display returns fast — sleep the unspent slice, never hot-spin
                         const spent = Date.now() - sliceStart;
@@ -499,7 +499,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     const next = failover("quota-failover");
                     journal.append("quota-failover", t.id, { from: channelKey(assignment), to: next ? channelKey(next) : null });
                     if (next) {
-                        await driver.notify(`drovr ${runId}: ${t.id} quota failover`, { tier: "attention" });
+                        await driver.notify(`tickmarkr ${runId}: ${t.id} quota failover`, { tier: "attention" });
                         // OBS-17 T2: the superseded slot's pane closes AT REROUTE TIME — it holds a throttled
                         // dead-end, not failure context; the next safe-point reconcile catches a missed close.
                         if (!keepForever) {
@@ -561,7 +561,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                             });
                         }
                     }
-                    journal.append("gate-result", t.id, { gate: g.gate, pass: g.pass, details: g.details });
+                    journal.append("gate-result", t.id, { gate: g.gate, pass: g.pass, details: g.details, ...(g.meta?.skipped === true ? { skipped: true } : {}) });
                     // v1.1 failover: never re-ask a reviewer channel that produced garbage for this task
                     if (g.gate === "review" && !g.pass && /unparseable/.test(g.details) && typeof g.meta?.reviewer === "string") {
                         badReviewers.push(g.meta.reviewer);
@@ -641,7 +641,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 feedback = results.filter((g) => !g.pass).map((g) => `${g.gate}: ${g.details}`).join("\n\n");
                 const step = r.ladder[Math.min(ladderIdx++, r.ladder.length - 1)];
                 journal.append("escalation", t.id, { step, attempt: attempt + 1 });
-                await driver.notify(`drovr ${runId}: ${t.id} escalation: ${step}`, { tier: "attention" });
+                await driver.notify(`tickmarkr ${runId}: ${t.id} escalation: ${step}`, { tier: "attention" });
                 if (step === "retry")
                     continue;
                 if (step === "escalate") {
@@ -711,7 +711,7 @@ export async function runDaemon(repoRoot, opts = {}) {
             .sort(([a], [b]) => a.localeCompare(b))
             .map(([root, count]) => `${count} blocked behind ${root}`)
             .join(", ");
-        await driver.notify(`drovr ${runId}: ${summary.done.length} done, ${summary.failed.length} failed, ${summary.human.length} awaiting human, ${summary.blocked.length} blocked, ${summary.pending.length} pending${attribution ? ` (${attribution})` : ""} — integration branch ${branch} (merge to main is yours)`, { tier: "attention" });
+        await driver.notify(`tickmarkr ${runId}: ${summary.done.length} done, ${summary.failed.length} failed, ${summary.human.length} awaiting human, ${summary.blocked.length} blocked, ${summary.pending.length} pending${attribution ? ` (${attribution})` : ""} — integration branch ${branch} (merge to main is yours)`, { tier: "attention" });
         return summary;
     }
     finally {

package/dist/run/git.js

@@ -7,14 +7,35 @@ import { drovrDir } from "../graph/graph.js";
 // (pi -p / codex exec wait for stdin EOF). timedOut distinguishes SIGKILL-timeout from a real nonzero exit.
 export function sh(cmd, cwd, timeoutMs = 600000) {
     return new Promise((resolve) => {
-        const p = spawn("bash", ["-lc", cmd], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        // detached: bash gets its own process group so a timeout can kill the whole tree —
+        // SIGKILLing bash alone orphans grandchildren (codex/pi) that hold the stdio pipes
+        // open, so "close" never fires and the promise wedges forever (v1.33.1 init hang).
+        const p = spawn("bash", ["-lc", cmd], { cwd, stdio: ["ignore", "pipe", "pipe"], detached: true });
         let stdout = "", stderr = "";
-        let timedOut = false;
-        const timer = setTimeout(() => { timedOut = true; p.kill("SIGKILL"); }, timeoutMs);
+        let timedOut = false, done = false;
+        const finish = (code, err) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            resolve({ code, stdout, stderr: err ?? stderr, timedOut });
+        };
+        const timer = setTimeout(() => {
+            timedOut = true;
+            try {
+                process.kill(-p.pid, "SIGKILL");
+            }
+            catch {
+                p.kill("SIGKILL");
+            }
+        }, timeoutMs);
         p.stdout.on("data", (d) => (stdout += d));
         p.stderr.on("data", (d) => (stderr += d));
-        p.on("error", (e) => { clearTimeout(timer); resolve({ code: 127, stdout, stderr: String(e), timedOut }); });
-        p.on("close", (code) => { clearTimeout(timer); resolve({ code: code ?? 1, stdout, stderr, timedOut }); });
+        p.on("error", (e) => finish(127, String(e)));
+        p.on("close", (code) => finish(code ?? 1));
+        // "close" waits for stdio to drain; a surviving pipe-holder must not outlive the timeout
+        p.on("exit", (code) => { if (timedOut)
+            finish(code ?? 1); });
     });
 }
 export async function shOk(cmd, cwd) {

package/dist/run/journal.d.ts

@@ -80,7 +80,9 @@ export declare class Journal {
     private constructor();
     static create(repoRoot: string, runId: string, narrate?: (event: JournalEvent) => void): Journal;
     static open(repoRoot: string, runId: string, narrate?: (event: JournalEvent) => void): Journal;
-    static latestRunId(repoRoot: string): string | null;
+    static latestRunId(repoRoot: string, opts?: {
+        withJournal?: boolean;
+    }): string | null;
     private get journalPath();
     append(event: string, taskId?: string, data?: Record<string, unknown>): void;
     read(): JournalEvent[];

package/dist/run/journal.js

@@ -157,10 +157,16 @@ export class Journal {
             throw new Error(`no journal for ${runId} at ${dir}`);
         return new Journal(dir, runId, narrate);
     }
-    static latestRunId(repoRoot) {
+    // withJournal: journal.jsonl appears at first append, after Journal.create mkdirs — a caller that
+    // will Journal.open the result (status, report) must fall back to the newest run that is actually
+    // readable, not throw on the mkdir-to-first-append window. Raw default stays for telemetry-scoped
+    // callers (profile cursor), where a journal-less run dir still counts.
+    static latestRunId(repoRoot, opts = {}) {
         if (!existsSync(runsDir(repoRoot)))
             return null;
-        const ids = readdirSync(runsDir(repoRoot)).filter((d) => d.startsWith("run-")).sort();
+        const ids = readdirSync(runsDir(repoRoot))
+            .filter((d) => d.startsWith("run-") && (!opts.withJournal || existsSync(join(runsDir(repoRoot), d, "journal.jsonl"))))
+            .sort();
         return ids.at(-1) ?? null;
     }
     get journalPath() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "1.33.0",
+  "version": "1.33.1",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",