tickmarkr 1.30.0 → 1.33.1

package/dist/cli/commands/status.js

@@ -6,6 +6,7 @@ const REFRESH_MS = 2000;
 // The timer must keep the process ALIVE: an unref'd timer here let the event loop drain after the
 // first frame, so a live `--watch` printed once and exited 0 (OBS-11). Never unref this.
 const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const GATE_KEYS = { build: "B", test: "T", lint: "L", evidence: "E", scope: "S", acceptance: "A", review: "R" };
 const attemptStartIdx = (events, taskId) => {
     let idx = -1;
     for (let i = 0; i < events.length; i++) {
@@ -15,39 +16,58 @@ const attemptStartIdx = (events, taskId) => {
     }
     return idx;
 };
-/** Derive the live phase column for one task. Counts only that task's events since its last dispatch/escalation. */
-export const derivePhase = (task, events, channel) => {
-    const startIdx = attemptStartIdx(events, task.id);
-    if (startIdx < 0)
-        return "";
-    // Scope to this task — concurrent tasks' events must not leak into the attempt window (D-03).
-    const attempt = events.slice(startIdx).filter((e) => e.taskId === task.id);
-    if (attempt.some((e) => e.event === "task-done" || e.event === "task-failed" || e.event === "task-human"))
-        return "";
-    if (!attempt.some((e) => e.event === "task-dispatch"))
-        return "retrying"; // escalation before re-dispatch
-    if (!attempt.some((e) => e.event === "worker-result"))
-        return channel ? `worker · ${channel}` : "worker";
-    const enabled = GATE_NAMES.filter((g) => task.gates.includes(g));
-    const n = enabled.length;
-    const gateResults = attempt.filter((e) => e.event === "gate-result");
-    if (gateResults.length > 0) {
-        const last = gateResults[gateResults.length - 1];
-        if (!last.data.pass)
-            return `gate ✗ ${last.data.gate}`;
+const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
+const color = (text, code, enabled) => enabled ? `\x1b[${code}m${text}\x1b[0m` : text;
+const taskBox = (status, unicode) => {
+    if (unicode) {
+        if (status === "done")
+            return "✓";
+        if (status === "failed")
+            return "✗";
+        if (status === "human")
+            return "⏸";
+        return "☐";
     }
-    const passed = new Set();
-    for (const e of gateResults)
-        if (e.data.pass)
-            passed.add(String(e.data.gate));
-    const k = passed.size;
-    // n===0 (no enabled gates) → merge window immediately after worker-result
-    if (n === 0 || k >= n) {
-        if (!attempt.some((e) => e.event === "merge" || e.event === "task-done"))
-            return "merging";
-        return "";
+    if (status === "done")
+        return "[x]";
+    if (status === "failed" || status === "human")
+        return "[!]";
+    return "[ ]";
+};
+const gateBox = (state, unicode) => {
+    if (unicode)
+        return state === "pass" ? "✓" : state === "fail" ? "✗" : state === "skip" ? "·" : "☐";
+    return state === "pass" ? "[x]" : state === "fail" ? "[!]" : state === "skip" ? "." : "[ ]";
+};
+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.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 ${k + 1}/${n} ${enabled[k]}`;
+    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)
+        return clause;
+    if (max <= 3)
+        return clause.slice(0, Math.max(0, max));
+    return `${clause.slice(0, max - 3).trimEnd()}...`;
 };
 // VIS-11 (v1.13): a liveness header for renderFrame — last journal event age + whether the recorded
 // daemon pid is still alive. Honest about unknowns: a pre-v1.13 journal with no pid renders "unknown",
@@ -72,14 +92,14 @@ const daemonPid = (events) => {
     }
     return undefined;
 };
-const livenessLine = (events) => {
+const liveness = (events) => {
     const last = events.at(-1);
     if (!last)
-        return null; // nothing to be honest about
+        return "last event unknown · daemon pid unknown";
     const age = fmtAge(Date.now() - Date.parse(last.ts));
     const pid = daemonPid(events);
     if (pid === undefined)
-        return `  last event ${age} ago · daemon pid unknown`;
+        return `last event ${age} ago · daemon pid unknown`;
     let state;
     try {
         process.kill(pid, 0);
@@ -88,17 +108,14 @@ const livenessLine = (events) => {
     catch (k) {
         state = k.code === "ESRCH" ? "dead" : "alive";
     } // EPERM ⇒ alive
-    return `  last event ${age} ago · daemon pid ${pid} ${state}`;
+    return `last event ${age} ago · daemon pid ${pid} ${state}`;
 };
 const renderFrame = (cwd) => {
     const g = loadGraph(cwd);
-    const runId = Journal.latestRunId(cwd);
+    const runId = Journal.latestRunId(cwd, { withJournal: true });
     const assignments = new Map();
-    const gates = new Map();
     let replayed = null;
     let events = [];
-    // v1.23 T2: latest known context tokens per task (from context-sample journal events). Informational
-    // only — never feeds status/phase/gate classification (derivePhase and replayStatuses ignore them).
     const contexts = new Map();
     if (runId) {
         const j = Journal.open(cwd, runId);
@@ -107,11 +124,8 @@ const renderFrame = (cwd) => {
         for (const e of events) {
             if (e.event === "task-dispatch" && e.taskId) {
                 const a = e.data.assignment;
-                assignments.set(e.taskId, `${a.adapter}:${a.model}`);
-            }
-            if (e.event === "gate-result" && e.taskId) {
-                const prev = gates.get(e.taskId) ?? "";
-                gates.set(e.taskId, `${prev}${e.data.pass ? "✓" : "✗"}${e.data.gate} `);
+                if (typeof a.adapter === "string" && typeof a.model === "string")
+                    assignments.set(e.taskId, `${a.adapter}:${a.model}`);
             }
             if (e.event === "context-sample" && e.taskId && typeof e.data.tokens === "number" && Number.isFinite(e.data.tokens)) {
                 contexts.set(e.taskId, e.data.tokens); // last write wins
@@ -121,22 +135,65 @@ const renderFrame = (cwd) => {
     const effective = { ...g, tasks: g.tasks.map((t) => ({ ...t, status: replayed?.get(t.id) ?? t.status })) };
     const starved = new Set(blockedTasks(effective).map((t) => t.id));
     const waiting = new Set(pendingTasks(effective).map((t) => t.id));
-    const rows = g.tasks.map((t) => {
+    const unicode = visual();
+    const divider = unicode ? " · " : " / ";
+    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 phase = derivePhase(t, events, assignments.get(t.id)) || "-";
-        const base = assignments.get(t.id) ?? "-";
-        const ctx = contexts.get(t.id);
-        // Informational suffix only when known — never invents 0 from absence.
-        const assignCol = ctx !== undefined ? `${base} · ctx ${ctx}` : base;
-        return `  ${t.id.padEnd(6)} ${String(st).padEnd(8)} ${phase.padEnd(28)} ${assignCol.padEnd(28)} ${gates.get(t.id) ?? ""}${label}`;
+        const channel = assignments.get(t.id) ?? "-";
+        const assignCol = contexts.has(t.id) ? `${channel}${divider}ctx ${contexts.get(t.id)}` : channel;
+        return { t, st, label, assignCol, states: gateStates(t, events) };
+    });
+    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 [
-        `drovr status${runId ? ` — run ${runId}` : " — no runs yet"}`,
-        ...(runId ? [livenessLine(events)].filter((l) => l !== null) : []),
-        "  task   status   phase                        assignment                   gates",
-        ...rows,
-    ].join("\n");
+    return [header, rule, legend, ...rows].join("\n");
 };
 export async function status(argv, cwd = process.cwd(), opts = {}) {
     if (!argv.includes("--watch"))
@@ -146,11 +203,11 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
     const bounded = Number.isFinite(iterations);
     const frames = [];
     const sep = "\n---\n";
-    const tty = process.stdout.isTTY;
+    const tty = visual();
     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/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 = "drovr \u2014 spec-driven orchestration harness for AI coding agents\nusage: drovr <command>\n  init          guided setup + doctor\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 .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 function dispatch(cmd: string | undefined, argv: string[], commands?: CommandMap): Promise<{
     out: string;
     code: number;

package/dist/cli/index.js

@@ -16,9 +16,9 @@ import { unlock } from "./commands/unlock.js";
 export const COMMANDS = {
     init, doctor, compile, scope, plan, run, status, resume, report, profile, unlock, approve,
 };
-export const USAGE = `drovr — spec-driven orchestration harness for AI coding agents
-usage: drovr <command>
-  init          guided setup + doctor
+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)
   scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)
@@ -41,7 +41,7 @@ export async function dispatch(cmd, argv, commands = COMMANDS) {
         return { out: await fn(argv), code: 0 };
     }
     catch (err) {
-        return { out: `drovr ${cmd}: ${err.message}`, code: 1 };
+        return { out: `tickmarkr ${cmd}: ${err.message}`, code: 1 };
     }
 }
 /* v8 ignore start -- binary entry: printing + process.exit side effects, not unit-testable (ROADMAP crit 2) */

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

@@ -1,7 +1,7 @@
 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*drovr:spec(?:\s+v1)?\s*-->\s*$/m;
+export const NATIVE_MARKER = /^<!--\s*(?:tickmarkr|drovr):spec(?:\s+v1)?\s*-->\s*$/m;
 const HEAD_RE = /^## (T\d+):\s*(.+)$/;
 const FIELD_RE = /^- (\w+):\s*(.*)$/;
 const NESTED_RE = /^\s+- (.+)$/;
@@ -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;
 }
@@ -143,11 +143,11 @@ export function compileNative(file) {
 // 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() {
-    return `<!-- drovr:spec -->
-# drovr native spec
+    return `<!-- tickmarkr: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/herdr.d.ts

@@ -11,10 +11,13 @@ export declare class HerdrDriver implements ExecutorDriver {
     private groups;
     private groupSerial;
     private ws;
+    private callerPane;
+    private watches;
     constructor(bin?: string, workersPerTab?: number);
     private serial;
     static available(): boolean;
     private herdr;
+    private namedPaneId;
     private paneId;
     private paneWidth;
     slot(cwd: string, name: string, opts?: SlotOpts): Promise<Slot>;
@@ -36,6 +39,8 @@ export declare class HerdrDriver implements ExecutorDriver {
     notify(msg: string, opts?: NotifyOpts): Promise<void>;
     close(slot: Slot): Promise<void>;
     private closeGrouped;
+    private priorWatch;
+    private watchSlot;
     narrator(cwd: string, command: string, runId?: string): Promise<Slot>;
     reconcile(desired: Set<string>, runId: string, opts?: {
         spareLiveLlm?: boolean;

package/dist/drivers/herdr.js

@@ -1,7 +1,7 @@
 import { shq } from "../adapters/types.js";
 import { createWorktree, sh } from "../run/git.js";
 import { herdrSealShellPrefix } from "./subprocess.js";
-import { canonicalizeLegacyName, formatOwnedName, panesToClose } from "./types.js";
+import { canonicalizeLegacyName, formatOwnedName, panesToClose, parseOwnedName } from "./types.js";
 // VIS-09 P43-03: adopted safety floor from 43-MEASUREMENT.md (narrowest safe 53 → floor 108).
 export const TRAILER_SAFE_FLOOR_COLS = 108;
 export const TRAILER_WIDTH_MARGIN = 2; // cols below (floor + margin) refuse a rightward first split
@@ -24,6 +24,8 @@ export class HerdrDriver {
     // operator's env before the driver is built). Required at slot() time, never in the constructor —
     // pickDriver and its unit test construct HerdrDriver without env, so slot() is the trust gate.
     ws = process.env.HERDR_WORKSPACE_ID;
+    callerPane = process.env.HERDR_PANE_ID;
+    watches = new Map();
     constructor(bin = "herdr", workersPerTab = 3) {
         this.bin = bin;
         this.workersPerTab = workersPerTab;
@@ -39,18 +41,21 @@ export class HerdrDriver {
     herdr(args, cwd = process.cwd(), timeoutMs) {
         return sh(`${shq(this.bin)} ${args}`, cwd, timeoutMs);
     }
-    // pane ids compact when panes close — resolve fresh via the durable agent name (spec §5)
-    async paneId(slot) {
-        const r = await this.herdr(`agent get ${shq(slot.name)}`);
+    async namedPaneId(name) {
+        const r = await this.herdr(`agent get ${shq(name)}`);
+        if (r.code !== 0)
+            return null;
         try {
             const id = JSON.parse(r.stdout).result?.agent?.pane_id;
-            if (typeof id === "string" && id)
-                return id;
+            return typeof id === "string" && id ? id : null;
         }
         catch {
-            /* fall back to cached id */
+            return null;
         }
-        return slot.id;
+    }
+    // pane ids compact when panes close — resolve fresh via the durable agent name (spec §5)
+    async paneId(slot) {
+        return await this.namedPaneId(slot.name) ?? slot.id;
     }
     // VIS-09 P43-03: runtime width for the layout gate (43-MEASUREMENT.md licensing condition 2).
     async paneWidth(paneId) {
@@ -310,6 +315,13 @@ export class HerdrDriver {
         await this.herdr(`notification show ${shq(msg)} --sound ${opts?.tier === "attention" ? "request" : opts?.sound ?? "request"}`);
     }
     async close(slot) {
+        if (this.watches.get(slot.name)?.id === slot.id) {
+            this.watches.delete(slot.name);
+            const pane = await this.namedPaneId(slot.name);
+            if (pane)
+                await this.herdr(`pane close ${shq(pane)}`);
+            return; // run-end reconcile may already have reaped it; never close a compacted stale id
+        }
         if (slot.group && this.groups.has(slot.group)) {
             return this.serial(() => this.closeGrouped(slot));
         }
@@ -342,16 +354,95 @@ export class HerdrDriver {
                 this.groups.delete(slot.group); // group dies when all generations gone
         }
     }
-    // T6 narrator: the run's single live surface — a drovr-created "watch" tab running the daemon's
-    // status command. Reuses the dedicated-tab slot path (label → tabSlot); close() reaps the whole tab
-    // at run end. One per run (the daemon calls this once). Failures propagate — the daemon swallows.
-    // T2: with a runId the pane is named canonically (drovr:watch:run:0:<runId>) so reconcile owns it;
-    // the legacy `narrator-watch-<pid>` shape survives for runId-less callers (canonicalizeLegacyName).
+    async priorWatch(runId) {
+        if (!this.ws)
+            throw new Error("herdr watch placement requires HERDR_WORKSPACE_ID — refusing unseeded pane");
+        const list = await this.herdr("agent list");
+        if (list.code !== 0)
+            throw new Error(`herdr agent list failed: ${list.stderr || list.stdout}`);
+        let agents;
+        try {
+            agents = JSON.parse(list.stdout).result?.agents;
+        }
+        catch {
+            throw new Error(`herdr agent list returned unparseable JSON: ${list.stdout}`);
+        }
+        if (!Array.isArray(agents))
+            throw new Error(`herdr agent list returned no agents: ${list.stdout}`);
+        const prior = agents.find((a) => {
+            const owned = typeof a.name === "string" ? parseOwnedName(a.name) : null;
+            return a.workspace_id === this.ws && typeof a.pane_id === "string" && owned?.role === "watch" && owned.taskId === "run" && owned.runId !== runId;
+        });
+        return prior?.pane_id ?? null;
+    }
+    // T2: the watch is a rightward sibling of the daemon's own pane, never a separate tab. Its durable
+    // owned name lets a resumed daemon find an already-running watch instead of stacking another one.
+    async watchSlot(cwd, name) {
+        if (!this.ws)
+            throw new Error("herdr watch placement requires HERDR_WORKSPACE_ID — refusing unseeded pane");
+        if (!this.callerPane)
+            throw new Error("herdr watch placement requires HERDR_PANE_ID — refusing untargeted split");
+        const sp = await this.herdr(`pane split ${shq(this.callerPane)} --direction right --no-focus`);
+        if (sp.code !== 0)
+            throw new Error(`herdr watch split failed: ${sp.stderr || sp.stdout}`);
+        let pane;
+        try {
+            pane = JSON.parse(sp.stdout).result?.pane?.pane_id;
+        }
+        catch {
+            /* fail closed below */
+        }
+        if (typeof pane !== "string" || !pane)
+            throw new Error(`herdr watch split returned no pane id: ${sp.stdout}`);
+        const renamed = await this.herdr(`agent rename ${shq(pane)} ${shq(name)}`);
+        if (renamed.code !== 0 || await this.namedPaneId(name) !== pane) {
+            await this.herdr(`pane close ${shq(pane)}`);
+            throw new Error(`herdr watch rename failed: ${renamed.stderr || renamed.stdout}`);
+        }
+        const seed = await this.herdr(`pane run ${shq(pane)} ${shq(`cd ${shq(cwd)}; export HERDR_WORKSPACE_ID=${shq(this.ws)}; ${herdrSealShellPrefix()}`)}`, cwd);
+        if (seed.code !== 0) {
+            await this.herdr(`pane close ${shq(pane)}`);
+            throw new Error(`herdr watch seed failed: ${seed.stderr || seed.stdout}`);
+        }
+        return { id: pane, name, cwd };
+    }
+    // T6 narrator: the run's single live status surface. Reuse a local or already-running owned watch;
+    // a new run reowns its prior watch, and only a newly split pane receives the watch command. The
+    // status command reads the latest run every frame, so the renamed pane follows the new run without
+    // interrupting the operator's watch loop. Failures propagate — the daemon swallows.
     async narrator(cwd, command, runId) {
         const name = runId ? formatOwnedName({ role: "watch", taskId: "run", attempt: 0, runId }) : `narrator-watch-${process.pid}`;
-        const s = await this.slot(cwd, name, { label: "watch" });
-        await this.run(s, command);
-        return s;
+        return this.serial(async () => {
+            const cached = this.watches.get(name);
+            if (cached)
+                return cached;
+            const existing = await this.namedPaneId(name);
+            if (existing) {
+                const s = { id: existing, name, cwd };
+                this.watches.set(name, s);
+                return s;
+            }
+            const prior = runId ? await this.priorWatch(runId) : null;
+            if (prior) {
+                const renamed = await this.herdr(`agent rename ${shq(prior)} ${shq(name)}`);
+                if (renamed.code !== 0 || await this.namedPaneId(name) !== prior) {
+                    throw new Error(`herdr watch reclaim failed: ${renamed.stderr || renamed.stdout}`);
+                }
+                const s = { id: prior, name, cwd };
+                this.watches.set(name, s);
+                return s;
+            }
+            const s = await this.watchSlot(cwd, name);
+            this.watches.set(name, s);
+            try {
+                await this.run(s, command);
+            }
+            catch (err) {
+                this.watches.delete(name);
+                throw err;
+            }
+            return s;
+        });
     }
     // OBS-17 T2 / v1.22b T1: close every drovr-owned pane that should not exist (superseded attempts,
     // killed-daemon orphans, leftovers from OLDER runs) — in this run's workspace OR misplaced in any

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

@@ -20,19 +20,20 @@ export function parseOwnedName(name) {
 export function isForeignName(name) {
     return parseOwnedName(name) === null;
 }
-// v1.22b T1: workspace-aware fold over a fleet snapshot — decides which owned panes are garbage
+// v1.22b T1: workspace-aware fold over a fleet snapshot — decides which owned task panes are garbage
 // right now. In-workspace: the existing desired-set/spareLiveLlm sweep (OBS-17 T2). Out-of-workspace:
 // an owned pane from a DIFFERENT run is a misplaced leftover (bug, foreign actor, pre-VIS-10 relic)
 // and closes regardless of `desired`; an owned pane from THIS run elsewhere is left alone — a live
 // run can legitimately hold panes across workspaces, so only run age marks a misplaced pane garbage.
-// Foreign names (parseOwnedName fails) are never candidates, in any workspace.
+// Watch panes are operator-owned after run end and are reclaimed by the next run; foreign names
+// (parseOwnedName fails) are never candidates, in any workspace.
 export function panesToClose(agents, desired, ws, runId, opts) {
     const out = [];
     for (const a of agents) {
         if (typeof a.name !== "string" || typeof a.paneId !== "string")
             continue;
         const owned = parseOwnedName(a.name);
-        if (!owned)
+        if (!owned || owned.role === "watch")
             continue;
         if (a.workspaceId === ws) {
             if (desired.has(a.name))

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" });