tickmarkr 1.37.0 → 1.40.0

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 -->";
@@ -13,18 +13,51 @@ const DOCS_END = "<!-- tickmarkr:agent-docs end -->";
 const AGENT_DOCS = `${DOCS_BEGIN}
 ## tickmarkr
 
-tickmarkr turns repository specs into isolated, independently verified agent work. Use \`/tickmarkr-loop\` for one spec or \`/tickmarkr-auto\` for several.
+tickmarkr compiles repository specs into isolated, independently verified agent work.
 
-Loop: \`tickmarkr compile <spec>\` → \`tickmarkr plan\` → \`tickmarkr run\` → \`tickmarkr report <runId> --md\`.
+### Invariants
 
 - Never run two tickmarkr runs in the same repository concurrently.
-- Never merge tickmarkr work directly to main; new runs consolidate on \`tickmarkr/<runId>\`.
-- Fix source specs instead of editing generated graphs.
-- Never trust a worker's completion claim; gates independently verify the work.
-- Treat missing or unparseable results as failures.
+- Never let tickmarkr merge work to main; new runs consolidate on \`tickmarkr/<runId>\`.
+- Do not edit compiled graphs to force outcomes; fix source specs and recompile.
+- Gates verify commits, diffs, acceptance criteria, and reviews independently — never trust a worker's completion claim.
+- Treat missing or unparseable machine results and verdicts as failures.
+
+### Commands
+
+- \`tickmarkr compile <spec>\` — spec → RunGraph
+- \`tickmarkr plan\` — routing table and human gates
+- \`tickmarkr run\` — execute the graph
+- \`tickmarkr status <runId>\` — run progress
+- \`tickmarkr resume <runId>\` — continue a paused or failed run
+- \`tickmarkr approve <runId> <taskId>\` — release a human gate
+- \`tickmarkr report <runId> --md\` — execution record beside the spec
+
+Loop: compile → plan → run → report. Watch the journal for run-end rather than polling workers.
+
+### Role check (multi-agent environments)
+
+- **Orchestrator:** run the loop in your session; do not start a second run.
+- **Supervisor with a live orchestrator:** relay the mission via verified handoff (below), then supervise — do not duplicate the loop.
+- **Primary session without an orchestrator:** spawn one child orchestration session, give it the mission and these rules, then supervise.
+
+Outside multi-agent environments, run the loop directly.
+
+### Version preflight
+
+Before \`tickmarkr compile\` or \`tickmarkr run\`: run \`tickmarkr version\`, read \`package.json\` version, and if the binary is older on major.minor, stop and tell the operator to update. Never proceed on hope — stale binaries silently skip daemon gates.
+
+### Tip-verify-before-green
+
+A run is green only when the run-end event exists in the journal AND tip verify is not "failed". Never report green to the operator, tab titles, or records until both hold.
+
+### Verified handoffs
+
+When relaying missions between agents, never use bare send-text (\`herdr agent send\` / pane send-text) — it omits Enter. Use \`herdr pane run <pane> "<message>"\` or \`herdr notification show "<message>"\`. Confirm delivery by reading the target pane afterward; never report "relayed" without read-back.
 ${DOCS_END}
 `;
-const skillPath = (cwd, skill) => join(cwd, ".claude", "skills", skill, "SKILL.md");
+const skillsRoot = (cwd) => existsSync(join(cwd, ".claude", "skills")) ? join(cwd, ".claude", "skills") : join(cwd, ".agents", "skills");
+const skillPath = (cwd, skill) => join(skillsRoot(cwd), skill, "SKILL.md");
 const skillsInstalled = (cwd) => AGENT_SKILLS.every((s) => existsSync(skillPath(cwd, s)));
 const wizardDriverDefault = () => process.env.HERDR_ENV === "1" ? "herdr" : "auto";
 async function installAgentFiles(cwd, force, docs, notes) {
@@ -44,7 +77,7 @@ async function installAgentFiles(cwd, force, docs, notes) {
                 notes.push(`skipped existing ${dest}; pass --force to overwrite it`);
                 continue;
             }
-            mkdirSync(join(cwd, ".claude", "skills", skill), { recursive: true });
+            mkdirSync(join(skillsRoot(cwd), skill), { recursive: true });
             writeFileSync(dest, readFileSync(new URL(`../../../skills/${skill}/SKILL.md`, import.meta.url)), exists ? undefined : { flag: "wx" });
             notes.push(`${exists ? "overwrote" : "wrote"} ${dest}`);
         }
@@ -52,7 +85,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}?`)) {
@@ -94,8 +128,8 @@ async function runInitWizard(cwd) {
         const llm = llmRaw === "pane" || llmRaw === "headless" ? llmRaw : llmDef;
         let installSkills = false;
         if (!skillsInstalled(cwd)) {
-            const skillsDef = existsSync(join(cwd, ".claude")) && !skillsInstalled(cwd);
-            installSkills = await askYesNo(rl, "Install agent skills (tickmarkr-loop/tickmarkr-auto) into .claude/skills?", skillsDef);
+            const skillsDef = existsSync(join(cwd, ".claude", "skills")) && !skillsInstalled(cwd);
+            installSkills = await askYesNo(rl, "Install agent skills (tickmarkr-loop/tickmarkr-auto)?", skillsDef);
         }
         return { overlay: { driver, concurrency, visibility: { llm } }, installSkills };
     }
@@ -126,7 +160,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 +168,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/plan.js

@@ -5,7 +5,15 @@ import { loadConfig } from "../../config/config.js";
 import { loadGraph } from "../../graph/graph.js";
 import { excludedChannels, exclusionLine } from "../../route/preference.js";
 import { route, RoutingError } from "../../route/router.js";
+import { modelId } from "../../gates/review.js";
 import { loadRoutingProfile } from "../../run/journal.js";
+const fleetCanCrossVendorReview = (channels) => {
+    for (let i = 0; i < channels.length; i++)
+        for (let j = 0; j < channels.length; j++)
+            if (i !== j && channels[i].vendor !== channels[j].vendor && modelId(channels[i].model) !== modelId(channels[j].model))
+                return true;
+    return false;
+};
 export async function plan(_argv, cwd = process.cwd(), adapters = allAdapters()) {
     // ponytail: hardcoded 24h TTL — promote to config when an operator asks. mtime is the signal because
     // doctor.json has no probe timestamp and a schema field would break the existing-files compat invariant.
@@ -59,6 +67,9 @@ export async function plan(_argv, cwd = process.cwd(), adapters = allAdapters())
             lints.push(`${role}: ${sel.adapter}:${sel.model} not installed — that gate/consult will fail closed`);
     }
     lints.push(...modelLints(cfg, health, adapters, { tty: ttyVisual() })); // health may be pre-v1.5/probeAll-fallback — no-detection branch covers both
+    if (cfg.review.required && channels.length && !fleetCanCrossVendorReview(channels)) {
+        lints.push("review: no cross-vendor reviewer pair in fleet — set review.required: false to waive");
+    }
     let cost = 0;
     for (const t of g.tasks) {
         try {
@@ -69,7 +80,7 @@ export async function plan(_argv, cwd = process.cwd(), adapters = allAdapters())
             }
             const est = r.assignment.channel === "sub" ? 0 : cfg.pricing[r.assignment.tier];
             cost += est;
-            lines.push(`  ${t.id.padEnd(6)} ${t.shape.padEnd(10)} c${String(t.complexity).padEnd(3)}→ ${r.assignment.adapter}:${r.assignment.model} [${r.assignment.channel}/${r.assignment.tier}]${t.humanGate ? " (human gate)" : ""}${est ? ` ~$${est.toFixed(2)}` : ""} — ${r.provenance}`);
+            lines.push(`  ${t.id.padEnd(6)} ${t.shape.padEnd(10)} c${String(t.complexity).padEnd(3)}→ ${r.assignment.adapter}:${r.assignment.model} [${r.assignment.channel}/${r.assignment.tier}]${t.timeoutMinutes !== undefined ? ` (timeout ${t.timeoutMinutes}m)` : ""}${t.humanGate ? " (human gate)" : ""}${est ? ` ~$${est.toFixed(2)}` : ""} — ${r.provenance}`);
             if (r.deviation) {
                 deviations++;
                 const d = r.deviation;

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/resume.d.ts

@@ -1 +1,4 @@
-export declare function resume(argv: string[], cwd?: string): Promise<string>;
+export declare function resume(argv: string[], cwd?: string): Promise<{
+    out: string;
+    code: number;
+}>;

package/dist/cli/commands/resume.js

@@ -2,10 +2,13 @@ import { loadConfig } from "../../config/config.js";
 import { pickDriver } from "../../drivers/index.js";
 import { formatSummary, runDaemon } from "../../run/daemon.js";
 import { formatJournalNarration } from "../../run/journal.js";
+const summaryGreen = (s) => s.failed.length === 0 && s.human.length === 0 && s.blocked.length === 0 && s.pending.length === 0
+    && s.tipVerify !== "failed";
 export async function resume(argv, cwd = process.cwd()) {
     const runId = argv[0];
     if (!runId)
         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)}`;
+    const out = `resumed ${s.runId} — ${formatSummary(s)}`;
+    return { out, code: summaryGreen(s) ? 0 : 2 };
 }

package/dist/cli/commands/run.d.ts

@@ -1 +1,4 @@
-export declare function run(argv: string[], cwd?: string): Promise<string>;
+export declare function run(argv: string[], cwd?: string): Promise<{
+    out: string;
+    code: number;
+}>;

package/dist/cli/commands/run.js

@@ -6,6 +6,8 @@ import { loadGraph } from "../../graph/graph.js";
 import { formatSummary, runDaemon } from "../../run/daemon.js";
 import { route } from "../../route/router.js";
 import { formatJournalNarration, loadRoutingProfile } from "../../run/journal.js";
+const summaryGreen = (s) => s.failed.length === 0 && s.human.length === 0 && s.blocked.length === 0 && s.pending.length === 0
+    && s.tipVerify !== "failed";
 export async function run(argv, cwd = process.cwd()) {
     const { values } = parseArgs({
         args: argv,
@@ -15,6 +17,11 @@ export async function run(argv, cwd = process.cwd()) {
             "route-strict": { type: "boolean" },
         },
     });
+    if (values.concurrency !== undefined) {
+        const n = Number(values.concurrency);
+        if (!Number.isInteger(n) || n <= 0)
+            throw new Error(`--concurrency must be a positive integer (got ${values.concurrency})`);
+    }
     const cfg = loadConfig(cwd);
     if (values["route-strict"]) {
         const adapters = allAdapters();
@@ -31,5 +38,6 @@ export async function run(argv, cwd = process.cwd()) {
         driver: pickDriver(cfg, values.driver),
         narrate: (event) => console.log(formatJournalNarration(event)),
     });
-    return `run ${s.runId} finished — ${formatSummary(s)} (merge to main is a human decision)`;
+    const out = `run ${s.runId} finished — ${formatSummary(s)} (merge to main is a human decision)`;
+    return { out, code: summaryGreen(s) ? 0 : 2 };
 }

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/commands/version.d.ts

@@ -0,0 +1 @@
+export declare function version(_argv?: string[]): Promise<string>;

package/dist/cli/commands/version.js

@@ -0,0 +1,8 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "../../../package.json");
+export async function version(_argv = []) {
+    const { version: v } = JSON.parse(readFileSync(pkgPath, "utf8"));
+    return v;
+}

package/dist/cli/index.d.ts

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

package/dist/cli/index.js

@@ -13,26 +13,19 @@ import { run } from "./commands/run.js";
 import { scope } from "./commands/scope.js";
 import { status } from "./commands/status.js";
 import { unlock } from "./commands/unlock.js";
+import { version } from "./commands/version.js";
+const normalize = (r) => typeof r === "string" ? { out: r, code: 0 } : r;
 export const COMMANDS = {
-    init, doctor, compile, scope, plan, run, status, resume, report, profile, unlock, approve,
+    init, doctor, compile, scope, plan, run, status, resume, report, profile, unlock, approve, version,
 };
+const VERSION_FLAGS = new Set(["version", "--version", "-v"]);
 const HELP_CMDS = new Set(["help", "-h", "--help"]);
-// 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");
+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)
@@ -43,9 +36,11 @@ 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) {
+    if (cmd && VERSION_FLAGS.has(cmd))
+        return { out: await version(argv), code: 0 };
     const usage = process.stdout.isTTY ? BANNER + USAGE : USAGE;
     if (!cmd || HELP_CMDS.has(cmd))
         return { out: usage, code: 0 };
@@ -53,7 +48,7 @@ export async function dispatch(cmd, argv, commands = COMMANDS) {
     if (!fn)
         return { out: usage, code: 1 };
     try {
-        return { out: await fn(argv), code: 0 };
+        return normalize(await fn(argv));
     }
     catch (err) {
         return { out: `tickmarkr ${cmd}: ${err.message}`, code: 1 };
@@ -61,7 +56,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]) : "";
 }
@@ -72,7 +67,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.endsWith(USAGE) || code === 0 ? console.log : console.error)(out);
+        (code === 1 && !out.endsWith(USAGE) ? console.error : console.log)(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,14 +1,16 @@
 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+- (.+)$/;
 // v1.19: a typed acceptance oracle line — "command: ...", "test: ...", or "judge: ...". Anything
 // without one of these prefixes is a plain-string judge criterion (compat path, emits a warning).
 const ORACLE_RE = new RegExp(`^(${ORACLES.join("|")}):\\s*(.*)$`);
-const FIELDS = new Set(["goal", "shape", "deps", "files", "context", "complexity", "humangate", "pin", "floor", "gates", "acceptance"]);
+const FIELDS = new Set(["goal", "shape", "deps", "files", "context", "complexity", "humangate", "pin", "floor", "gates", "acceptance", "timeout"]);
 function invalid(task, field, detail) {
     throw new CompileError(`Task ${task} field "${field}" ${detail}`);
 }
@@ -108,6 +110,10 @@ export function compileNative(file) {
         const badGate = draft.gates.find((gate) => !GATE_NAMES.includes(gate));
         if (badGate)
             invalid(draft.id, "gates", `contains invalid gate "${badGate}"`);
+        const timeoutMinutes = fields.timeout === undefined ? undefined : Number(fields.timeout);
+        if (fields.timeout !== undefined && (!Number.isFinite(timeoutMinutes) || timeoutMinutes <= 0)) {
+            invalid(draft.id, "timeout", "must be a positive number");
+        }
         const routingHints = pin || fields.floor ? {
             ...(pin ? { pin: { via: pin[0], model: pin[1] } } : {}),
             ...(fields.floor ? { floor: fields.floor } : {}),
@@ -123,6 +129,7 @@ export function compileNative(file) {
             context: csv(fields.context),
             acceptance: draft.acceptance,
             ...(fields.humangate === "true" ? { humanGate: true } : {}),
+            ...(timeoutMinutes !== undefined ? { timeoutMinutes } : {}),
             ...(routingHints ? { routingHints } : {}),
             ...(draft.hasGates ? { gates: draft.gates } : {}),
         };
@@ -139,7 +146,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() {
@@ -164,7 +171,8 @@ acceptance is required on every task (a nested list of observable outcomes).
     humanGate:   true | false — pauses for a human review before merging this task
     pin:         "via model" — pin an exact channel, e.g. "claude-code opus"
     floor:       cheap | mid | frontier — minimum capability tier for routing
-    gates:       nested list, any of build | test | lint | evidence | scope | acceptance | review
+    gates:       nested list; build | test | lint | evidence | scope are mandatory;
+                 acceptance | review may be omitted
     acceptance:  nested list (REQUIRED, non-empty). Each item is either a typed oracle or plain text:
                  - command: <shell>   (oracle: command — exit code)
                  - test: <name>       (oracle: test — named test)

package/dist/config/config.d.ts

@@ -6,6 +6,7 @@ declare const TierEnum: z.ZodEnum<{
 }>;
 export type Tier = z.infer<typeof TierEnum>;
 export declare const TIER_RANK: Record<Tier, number>;
+export declare const DEFAULT_DIFF_CAP = 60000;
 export declare const MapEntrySchema: z.ZodObject<{
     pin: z.ZodOptional<z.ZodObject<{
         via: z.ZodString;
@@ -46,7 +47,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";
@@ -84,6 +85,7 @@ export declare const DrovrConfigSchema: z.ZodObject<{
             halfLifeRuns: z.ZodOptional<z.ZodNumber>;
             availWeight: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
+        allowUnverifiedModels: z.ZodBoolean;
         allow: z.ZodOptional<z.ZodObject<{
             adapters: z.ZodOptional<z.ZodArray<z.ZodString>>;
             models: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -123,6 +125,7 @@ export declare const DrovrConfigSchema: z.ZodObject<{
         build: z.ZodOptional<z.ZodString>;
         test: z.ZodOptional<z.ZodString>;
         lint: z.ZodOptional<z.ZodString>;
+        diffCap: z.ZodOptional<z.ZodNumber>;
         byShape: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodEnum<{
             plan: "plan";
             spec: "spec";
@@ -171,23 +174,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;