tickmarkr 1.36.0 → 1.38.0

package/dist/drivers/herdr.js

@@ -74,7 +74,7 @@ export class HerdrDriver {
     }
     async slot(cwd, name, opts) {
         // T1 ownership contract: `opts.owned` (T2 call sites) names the pane canonically —
-        // drovr:<role>:<taskId>:<attempt>:<runId>. Without it, `name` passes through byte-identical
+        // tickmarkr:<role>:<taskId>:<attempt>:<runId>. Without it, `name` passes through byte-identical
         // (today's legacy daemon/gates/consult shapes) — canonicalizeLegacyName (types.ts) is what lets
         // reconcile.ts and this driver's own renameGroupTab/glyphFor decode role/taskId/attempt from
         // those shapes without a call-site migration; T2 retires this branch by always passing `owned`.
@@ -92,7 +92,7 @@ export class HerdrDriver {
     // named after a dead cursor worker and the operator read it as a mislabeled agent)
     async tabSlot(cwd, name, label = name) {
         // tab-per-slot: concurrent agents in one tab split it into sliver columns — TUIs exit or
-        // hard-wrap at COLUMNS≈2, shredding even the DROVR_RESULT marker (v1.4 phase-1 incident).
+        // hard-wrap at COLUMNS≈2, shredding even the TICKMARKR_RESULT marker (v1.4 phase-1 incident).
         // A dedicated named tab gives every agent a full-width pane; tab close() reaps it.
         // VIS-10 (operator ruling 2026-07-11): "pane placed by focus heuristic" is a DEFECT CLASS.
         // Fail closed at every step — env unset, tab-create non-zero, unparseable stdout, or a parsed
@@ -100,7 +100,7 @@ export class HerdrDriver {
         if (!this.ws)
             throw new Error("herdr placement requires HERDR_WORKSPACE_ID — refusing untargeted pane (VIS-10: fail closed, never place by focus)");
         // pin the tab to the RUN's workspace, UNCONDITIONALLY (inherited via HERDR_WORKSPACE_ID), never the
-        // operator's focused one (Intl-Dossier run-20260709-104447 incident: worker tabs opened in the drovr repo workspace)
+        // operator's focused one (Intl-Dossier run-20260709-104447 incident: worker tabs opened in the tickmarkr repo workspace)
         const t = await this.herdr(`tab create --label ${shq(label)} --no-focus --workspace ${shq(this.ws)}`);
         if (t.code !== 0)
             throw new Error(`herdr tab create failed (exit ${t.code}, refusing untargeted placement): ${t.stderr || t.stdout}`);
@@ -139,7 +139,7 @@ export class HerdrDriver {
         if (typeof id !== "string" || !id)
             throw new Error(`herdr agent start returned no pane id: ${r.stdout}`);
         // tab create auto-spawns a root shell pane and agent start --tab adds the agent as a SECOND
-        // pane — reap the idle shell so no tab shows a dead "drovr git:" prompt beside its agent
+        // pane — reap the idle shell so no tab shows a dead "tickmarkr git:" prompt beside its agent
         // (VIS-04 orphan fix). Best-effort: a failed reap costs cosmetics only.
         if (typeof rootPane === "string" && rootPane && rootPane !== id) {
             await this.herdr(`pane close ${shq(rootPane)}`);
@@ -444,7 +444,7 @@ export class HerdrDriver {
             return s;
         });
     }
-    // OBS-17 T2 / v1.22b T1: close every drovr-owned pane that should not exist (superseded attempts,
+    // OBS-17 T2 / v1.22b T1: close every tickmarkr-owned pane that should not exist (superseded attempts,
     // killed-daemon orphans, leftovers from OLDER runs) — in this run's workspace OR misplaced in any
     // other one — then reap the tabs those closes emptied. Ownership is decided ONLY by parseOwnedName
     // (drivers/types.ts panesToClose) — foreign names never become candidates, in any workspace; a pane

package/dist/drivers/index.d.ts

@@ -1,3 +1,3 @@
-import type { DrovrConfig } from "../config/config.js";
+import type { TickmarkrConfig } from "../config/config.js";
 import type { ExecutorDriver } from "./types.js";
-export declare function pickDriver(cfg: DrovrConfig, override?: "auto" | "herdr" | "subprocess"): ExecutorDriver;
+export declare function pickDriver(cfg: TickmarkrConfig, override?: "auto" | "herdr" | "subprocess"): ExecutorDriver;

package/dist/drivers/subprocess.js

@@ -1,8 +1,8 @@
 import { spawn } from "node:child_process";
 import { createWorktree } from "../run/git.js";
-// HARD-03: cap retained worker output so a chatty worker can't grow drovr's heap unbounded.
+// HARD-03: cap retained worker output so a chatty worker can't grow tickmarkr's heap unbounded.
 // 2MB is safe against BOTH consumers: the largest read() call site asks for 1000 lines
-// (daemon.ts:217/247), and every marker (DROVR_RESULT, DROVR_EXIT_<nonce>) is emitted at the
+// (daemon.ts:217/247), and every marker (TICKMARKR_RESULT, TICKMARKR_EXIT_<nonce>) is emitted at the
 // END of output — a trailer would only be evicted if >2MB arrived AFTER it inside one 200ms
 // waitOutput poll (~10MB/s sustained, far beyond agent-CLI rates). Tail-truncate, never head:
 // consumers only ever tail-read.
@@ -43,7 +43,7 @@ export class SubprocessDriver {
     }
     async run(slot, cmd) {
         const s = this.state(slot);
-        // HARD-05: interactive=false — no operator, so an open stdin pipe is a promise drovr can never
+        // HARD-05: interactive=false — no operator, so an open stdin pipe is a promise tickmarkr can never
         // keep; codex exec appends a piped stdin as a <stdin> block (`codex exec --help`) and blocks on a
         // read that never EOFs. One spawn site covers every adapter (D-06).
         // v1.22 T3: seal herdr control vars so worker/judge/review/consult children cannot reach the

package/dist/drivers/types.js

@@ -1,15 +1,13 @@
 // ---- Ownership contract (T1: OBS-17 pane-hygiene) --------------------------------------------
-// Every pane/tab drovr creates is identified by exactly one parseable token:
-//   drovr:<role>:<taskId>:<attempt>:<runId>
+// Every pane/tab tickmarkr creates is identified by exactly one parseable token:
+//   tickmarkr:<role>:<taskId>:<attempt>:<runId>
 // role ∈ OWNED_ROLES; attempt is a non-negative integer; taskId/runId never contain ":" (task and
 // run ids are alphanumeric/dash by construction elsewhere). formatOwnedName/parseOwnedName round-trip
 // exactly. parseOwnedName (or isForeignName) is the ONLY way reconcile.ts may decide a live pane name
-// is drovr-owned — anything that doesn't parse is foreign and is never a candidate for closing.
+// is tickmarkr-owned — anything that doesn't parse is foreign and is never a candidate for closing.
 export const OWNED_ROLES = ["worker", "judge", "review", "consult", "watch", "other"];
-// read-old/write-new: new panes are named tickmarkr:*, but reconcile still recognizes (and may
-// close/reuse) drovr:* panes left by pre-rename runs — resumed old runs keep working.
 const OWNED_PREFIX = "tickmarkr";
-const OWNED_RE = new RegExp(`^(?:${OWNED_PREFIX}|drovr):(${OWNED_ROLES.join("|")}):([^:]+):(\\d+):([^:]+)$`);
+const OWNED_RE = new RegExp(`^${OWNED_PREFIX}:(${OWNED_ROLES.join("|")}):([^:]+):(\\d+):([^:]+)$`);
 export function formatOwnedName(o) {
     return `${OWNED_PREFIX}:${o.role}:${o.taskId}:${o.attempt}:${o.runId}`;
 }

package/dist/gates/acceptance.js

@@ -58,7 +58,7 @@ export async function acceptanceGate(task, worktree, baseRef, judge, via, opts =
         ? "WARNING: only judge oracles — no deterministic command/test oracle guards this task (deterministic preferred, spec §2).\n"
         : "";
     const diff = (await shOk(`git diff '${baseRef}..HEAD'`, worktree)).slice(0, DIFF_CAP);
-    const prompt = `DROVR-JUDGE
+    const prompt = `TICKMARKR-JUDGE
 You are a strict acceptance judge. Decide whether the diff satisfies EVERY acceptance criterion.
 Judge only what the diff proves — plausible-but-wrong must fail. Do not award partial credit.
 Deterministic command/test oracles have already passed mechanically; judge ONLY the rubric items below.

package/dist/gates/baseline.d.ts

@@ -1,4 +1,4 @@
-import type { DrovrConfig } from "../config/config.js";
+import type { TickmarkrConfig } from "../config/config.js";
 import type { GateResult } from "./types.js";
 export interface Baseline {
     commands: Record<string, {
@@ -7,6 +7,6 @@ export interface Baseline {
     }>;
 }
 export declare function fingerprint(output: string): string[];
-export declare function detectGateCommands(repoRoot: string, cfg: DrovrConfig): Record<string, string>;
+export declare function detectGateCommands(repoRoot: string, cfg: TickmarkrConfig): Record<string, string>;
 export declare function captureBaseline(cwd: string, commands: Record<string, string>): Promise<Baseline>;
 export declare function compareToBaseline(cwd: string, commands: Record<string, string>, baseline: Baseline, enabled: string[]): Promise<GateResult[]>;

package/dist/gates/llm.js

@@ -2,6 +2,7 @@ import { mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { formatOwnedName, parseOwnedName } from "../drivers/types.js";
+import { bannerShell } from "../brand.js";
 import { sh } from "../run/git.js";
 export const GATE_PANE_SEP = " · ";
 /** T8: role-first pane name for fleet visibility — judge · T4, review · T3, consult · T2. */
@@ -12,7 +13,7 @@ export function gatePaneName(role, taskId, suffix = "") {
 // via.name remains the fallback for non-gate runViaDriver callers and carries -r1 retry suffixes.
 // T2 ownership contract: a canonical owned fallback (the daemon's nameFor now emits one) passes
 // through untouched; run-gates' "-r1" judge-retry suffix becomes attempt+1 so the retry pane's name
-// stays contract-parseable (drovr:judge:<task>:1:<runId>) instead of a corrupted-runId shape.
+// stays contract-parseable (tickmarkr:judge:<task>:1:<runId>) instead of a corrupted-runId shape.
 export function rolePaneNameFromPrompt(prompt, fallback) {
     const retry = fallback.endsWith("-r1");
     const base = retry ? fallback.slice(0, -3) : fallback;
@@ -22,14 +23,14 @@ export function rolePaneNameFromPrompt(prompt, fallback) {
     const id = prompt.match(/## Task ([^\n:]+):/)?.[1];
     if (!id)
         return fallback;
-    if (prompt.startsWith("DROVR-JUDGE"))
+    if (prompt.startsWith("TICKMARKR-JUDGE"))
         return gatePaneName("judge", id, retry ? "-r1" : "");
-    if (prompt.startsWith("DROVR-REVIEW"))
+    if (prompt.startsWith("TICKMARKR-REVIEW"))
         return gatePaneName("review", id, retry ? "-r1" : "");
     return fallback;
 }
 export async function runHeadless(adapter, model, prompt, cwd, timeoutMs = 300000) {
-    const pf = join(mkdtempSync(join(tmpdir(), "drovr-llm-")), "prompt.md");
+    const pf = join(mkdtempSync(join(tmpdir(), "tickmarkr-llm-")), "prompt.md");
     writeFileSync(pf, prompt);
     const r = await sh(adapter.headlessCommand(pf, model), cwd, timeoutMs);
     return r.stdout + "\n" + r.stderr;
@@ -37,15 +38,17 @@ export async function runHeadless(adapter, model, prompt, cwd, timeoutMs = 30000
 // v1.1 default path: the same headless CLI call, but dispatched through the driver
 // as a visible named agent (herdr pane), with the quote-split completion wrapper.
 export async function runViaDriver(adapter, model, prompt, cwd, via, timeoutMs = 300000) {
-    const pf = join(mkdtempSync(join(tmpdir(), "drovr-llm-")), "prompt.md");
+    const pf = join(mkdtempSync(join(tmpdir(), "tickmarkr-llm-")), "prompt.md");
     writeFileSync(pf, prompt);
     const slot = await via.driver.slot(cwd, rolePaneNameFromPrompt(prompt, via.name), via.label ? { label: via.label } : undefined);
     via.onSlot?.(slot);
-    await via.driver.run(slot, `${adapter.headlessCommand(pf, model)}; printf '\\nDROVR_''EXIT:%s\\n' $?`);
-    // wait for the digit-suffixed marker (a real $? exit code), never a bare "DROVR_EXIT:" that a
+    // brand banner at pane top — gate panes run headless-print (no alt screen), so it stays visible;
+    // extractJson is anchored to JSON braces and the exit marker to TICKMARKR_EXIT:\d, neither matches banner text
+    await via.driver.run(slot, `${bannerShell()}; ${adapter.headlessCommand(pf, model)}; printf '\\nTICKMARKR_''EXIT:%s\\n' $?`);
+    // wait for the digit-suffixed marker (a real $? exit code), never a bare "TICKMARKR_EXIT:" that a
     // self-referential diff under review merely DISPLAYS — same guard the worker path uses (daemon.ts:193).
-    // Without it, a judge/review pane echoing drovr's own source false-completes before its verdict lands.
-    await via.driver.waitOutput(slot, "DROVR_EXIT:\\d", timeoutMs, { regex: true });
+    // Without it, a judge/review pane echoing tickmarkr's own source false-completes before its verdict lands.
+    await via.driver.waitOutput(slot, "TICKMARKR_EXIT:\\d", timeoutMs, { regex: true });
     const out = await via.driver.read(slot, 400);
     if (!via.keep)
         await via.driver.close(slot);

package/dist/gates/review.d.ts

@@ -1,5 +1,5 @@
 import { type Assignment, type BillingChannel, type WorkerAdapter } from "../adapters/types.js";
-import { type DrovrConfig } from "../config/config.js";
+import { type TickmarkrConfig } from "../config/config.js";
 import { type Task } from "../graph/schema.js";
 import { type GateVia } from "./llm.js";
 import type { GateResult } from "./types.js";
@@ -9,4 +9,4 @@ export interface ReviewVerdict {
 }
 export declare function modelId(model: string): string;
 export declare function pickReviewer(author: Assignment, channels: BillingChannel[], exclude?: string[]): BillingChannel | null;
-export declare function reviewGate(task: Task, worktree: string, baseRef: string, author: Assignment, channels: BillingChannel[], adapters: WorkerAdapter[], cfg: DrovrConfig, via?: GateVia, excludeReviewers?: string[]): Promise<GateResult>;
+export declare function reviewGate(task: Task, worktree: string, baseRef: string, author: Assignment, channels: BillingChannel[], adapters: WorkerAdapter[], cfg: TickmarkrConfig, via?: GateVia, excludeReviewers?: string[]): Promise<GateResult>;

package/dist/gates/review.js

@@ -39,7 +39,7 @@ export async function reviewGate(task, worktree, baseRef, author, channels, adap
             : { gate: "review", pass: true, details: "WARNING: no cross-vendor reviewer available — review waived by config" };
     }
     const diff = (await shOk(`git diff '${baseRef}..HEAD'`, worktree)).slice(0, DIFF_CAP);
-    const prompt = `DROVR-REVIEW
+    const prompt = `TICKMARKR-REVIEW
 You are a skeptical cross-vendor code reviewer. Another agent (vendor: ${author.adapter}) authored this diff.
 Look for correctness bugs, security issues, and acceptance-criteria gaps. Approve only if you would merge it.
 

package/dist/gates/run-gates.d.ts

@@ -1,5 +1,5 @@
 import { type Assignment, type BillingChannel, type WorkerAdapter, type WorkerResult } from "../adapters/types.js";
-import { type DrovrConfig } from "../config/config.js";
+import { type TickmarkrConfig } from "../config/config.js";
 import { type GateName, type Task } from "../graph/schema.js";
 import { type Baseline } from "./baseline.js";
 import type { GateVia } from "./llm.js";
@@ -23,7 +23,7 @@ export interface GateContext {
     baseline: Baseline;
     channels: BillingChannel[];
     adapters: WorkerAdapter[];
-    cfg: DrovrConfig;
+    cfg: TickmarkrConfig;
     via?: GateVia;
     excludeReviewers?: string[];
     onGate?: (e: GateEvent) => void | Promise<void>;

package/dist/graph/graph.d.ts

@@ -1,7 +1,7 @@
 import { type RunGraph, type Task, type TaskStatus } from "./schema.js";
-export declare function stateDirName(repoRoot: string): string;
+export declare function stateDirName(_repoRoot: string): string;
 export declare function graphPath(repoRoot: string): string;
-export declare function drovrDir(repoRoot: string): string;
+export declare function tickmarkrDir(repoRoot: string): string;
 export declare function loadGraph(repoRoot: string): RunGraph;
 export declare function saveGraph(repoRoot: string, g: RunGraph): void;
 export declare function getTask(g: RunGraph, id: string): Task;

package/dist/graph/graph.js

@@ -1,25 +1,13 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { validateGraph } from "./schema.js";
-const stateDirs = new Map();
-export function stateDirName(repoRoot) {
-    const cached = stateDirs.get(repoRoot);
-    if (cached)
-        return cached;
-    const name = existsSync(join(repoRoot, ".tickmarkr"))
-        ? ".tickmarkr"
-        : existsSync(join(repoRoot, ".drovr"))
-            ? ".drovr"
-            : existsSync(join(repoRoot, ".drover"))
-                ? ".drover"
-                : ".tickmarkr";
-    stateDirs.set(repoRoot, name);
-    return name;
+export function stateDirName(_repoRoot) {
+    return ".tickmarkr";
 }
 export function graphPath(repoRoot) {
     return join(repoRoot, stateDirName(repoRoot), "graph.json");
 }
-export function drovrDir(repoRoot) {
+export function tickmarkrDir(repoRoot) {
     const dir = join(repoRoot, stateDirName(repoRoot));
     mkdirSync(dir, { recursive: true });
     const gi = join(dir, ".gitignore");
@@ -34,7 +22,7 @@ export function loadGraph(repoRoot) {
     return validateGraph(JSON.parse(readFileSync(p, "utf8")));
 }
 export function saveGraph(repoRoot, g) {
-    drovrDir(repoRoot);
+    tickmarkrDir(repoRoot);
     const p = graphPath(repoRoot);
     // Temp file MUST be a sibling of graph.json: rename(2) is atomic only within one filesystem
     // (never os.tmpdir()). pid-suffix so a racing writer can't clobber our in-flight temp (HARD-04).

package/dist/plan/prompt.js

@@ -1,5 +1,5 @@
 export function scopePrompt(intent, repair) {
-    return `DROVR-JUDGE
+    return `TICKMARKR-JUDGE
 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:

package/dist/plan/scope.d.ts

@@ -1,9 +1,9 @@
 import type { WorkerAdapter } from "../adapters/types.js";
-import type { DrovrConfig } from "../config/config.js";
+import type { TickmarkrConfig } from "../config/config.js";
 import type { ExecutorDriver } from "../drivers/types.js";
 export declare function clarificationGate(intent: string): string[];
 export interface ScopeOptions {
-    cfg: DrovrConfig;
+    cfg: TickmarkrConfig;
     adapters: WorkerAdapter[];
     driver?: ExecutorDriver;
     force?: boolean;

package/dist/plan/scope.js

@@ -2,7 +2,7 @@ import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "no
 import { tmpdir } from "node:os";
 import { basename, dirname, extname, join } from "node:path";
 import { discoverChannels, getAdapter, probeAll } from "../adapters/registry.js";
-import { compileNative, NATIVE_MARKER } from "../compile/native.js";
+import { compileNative, LEGACY_PREFIX } from "../compile/native.js";
 import { pickDriver } from "../drivers/index.js";
 import { extractJson, runLlm } from "../gates/llm.js";
 import { TaskSchema } from "../graph/schema.js";
@@ -48,7 +48,7 @@ function section(source, name) {
     return lines.slice(start + 1, end === -1 ? undefined : end).join("\n");
 }
 function extractDraft(raw) {
-    const clean = raw.replace(/\nDROVR_EXIT:\d[\s\S]*$/, "").trim();
+    const clean = raw.replace(/\nTICKMARKR_EXIT:\d[\s\S]*$/, "").trim();
     try {
         const value = JSON.parse(clean);
         if (typeof value === "string")
@@ -64,18 +64,18 @@ function extractDraft(raw) {
     const fenced = [...clean.matchAll(/```(?:markdown|md)?\s*\n([\s\S]*?)```/gi)].at(-1)?.[1];
     if (fenced)
         return fenced;
-    const marker = clean.search(/<!--\s*(?:tickmarkr|drovr):spec/);
+    const marker = clean.search(new RegExp(`<!--\\s*(?:tickmarkr|${LEGACY_PREFIX}):spec`));
     return (marker === -1 ? clean : clean.slice(marker)).trimEnd() + "\n";
 }
 function validateDraft(draft) {
-    if (!NATIVE_MARKER.test(draft))
+    if (!/^<!--\s*tickmarkr:spec/.test(draft))
         throw new Error("draft is missing the tickmarkr native marker");
     if (!section(draft, "Assumptions").trim())
         throw new Error("draft is missing explicit assumptions");
     const requirements = [...new Set(section(draft, "Requirements").match(/\bREQ-\d{2}\b/g) ?? [])];
     if (!requirements.length)
         throw new Error("draft has no REQ-nn requirements");
-    const dir = mkdtempSync(join(tmpdir(), "drovr-scope-compile-"));
+    const dir = mkdtempSync(join(tmpdir(), "tickmarkr-scope-compile-"));
     const file = join(dir, "draft.spec.md");
     try {
         writeFileSync(file, draft);

package/dist/route/preference.d.ts

@@ -1,10 +1,10 @@
 import { type AuthHealth } from "../adapters/types.js";
-import type { DrovrConfig } from "../config/config.js";
+import type { TickmarkrConfig } from "../config/config.js";
 export interface Disallowed {
     by: "deny" | "allow";
     entry: string;
 }
-export declare function excludedChannels(cfg: DrovrConfig, adapters: {
+export declare function excludedChannels(cfg: TickmarkrConfig, adapters: {
     id: string;
 }[] | string[], health: Record<string, AuthHealth>): {
     key: string;
@@ -17,11 +17,11 @@ export declare function exclusionLine(excluded: {
 export declare function preferRanks(c: {
     adapter: string;
     model: string;
-}, cfg: DrovrConfig): {
+}, cfg: TickmarkrConfig): {
     shape: string;
     rank: number;
 }[];
 export declare function disallowedBy(c: {
     adapter: string;
     model: string;
-}, routing: DrovrConfig["routing"]): Disallowed | null;
+}, routing: TickmarkrConfig["routing"]): Disallowed | null;

package/dist/route/router.d.ts

@@ -1,5 +1,5 @@
 import { type Assignment, type BillingChannel } from "../adapters/types.js";
-import { type DrovrConfig } from "../config/config.js";
+import { type TickmarkrConfig } from "../config/config.js";
 import type { Task } from "../graph/schema.js";
 import { type RoutingProfile } from "./profile.js";
 export type LadderStep = "retry" | "escalate" | "consult" | "human";
@@ -30,5 +30,5 @@ export declare class RoutingError extends Error {
     constructor(msg: string);
 }
 export declare function marginalCostRank(c: BillingChannel): number;
-export declare function route(task: Task, cfg: DrovrConfig, channels: BillingChannel[], profile?: RoutingProfile, preferCtx?: RoutingPreferContext): Route;
-export declare function nextChannel(current: Assignment, task: Task, cfg: DrovrConfig, channels: BillingChannel[], tried: string[], profile?: RoutingProfile): Assignment | null;
+export declare function route(task: Task, cfg: TickmarkrConfig, channels: BillingChannel[], profile?: RoutingProfile, preferCtx?: RoutingPreferContext): Route;
+export declare function nextChannel(current: Assignment, task: Task, cfg: TickmarkrConfig, channels: BillingChannel[], tried: string[], profile?: RoutingProfile): Assignment | null;

package/dist/run/consult.d.ts

@@ -1,5 +1,5 @@
 import type { WorkerAdapter } from "../adapters/types.js";
-import type { DrovrConfig } from "../config/config.js";
+import type { TickmarkrConfig } from "../config/config.js";
 import type { ExecutorDriver, Slot } from "../drivers/types.js";
 import type { GateResult } from "../gates/types.js";
 export interface ConsultVerdict {
@@ -16,7 +16,7 @@ export interface Dossier {
     gates: GateResult[];
 }
 export declare function buildDossierPrompt(d: Dossier): string;
-export declare function consult(d: Dossier, cfg: DrovrConfig, adapters: WorkerAdapter[], driver: ExecutorDriver, cwd: string, runDir: string, opts?: {
+export declare function consult(d: Dossier, cfg: TickmarkrConfig, adapters: WorkerAdapter[], driver: ExecutorDriver, cwd: string, runDir: string, opts?: {
     keep?: boolean;
     onSlot?: (slot: Slot) => void;
     runId?: string;

package/dist/run/consult.js

@@ -5,7 +5,7 @@ import { extractJson, gatePaneName } from "../gates/llm.js";
 import { sh } from "./git.js";
 const ACTIONS = ["retry", "reroute", "decompose", "human"];
 export function buildDossierPrompt(d) {
-    return `DROVR-CONSULT
+    return `TICKMARKR-CONSULT
 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.
 
@@ -37,7 +37,7 @@ Respond with ONLY this JSON:
 }
 let consultSeq = 0;
 export async function consult(d, cfg, adapters, driver, cwd, runDir, 
-// T2 ownership contract: runId names the consult pane canonically (drovr:consult:<task>:0:<runId>)
+// T2 ownership contract: runId names the consult pane canonically (tickmarkr:consult:<task>:0:<runId>)
 // via SlotOpts.owned; without it the legacy gatePaneName shape survives (non-daemon callers/tests).
 opts = {}) {
     const n = ++consultSeq;
@@ -58,10 +58,10 @@ opts = {}) {
             ...(opts.runId ? { owned: { role: "consult", taskId: d.taskId, attempt: 0, runId: opts.runId } } : {}),
         });
         opts.onSlot?.(slot);
-        await driver.run(slot, `${adapter.headlessCommand(promptFile, cfg.consult.model)}; printf '\\nDROVR_''EXIT:%s\\n' $?`);
-        // digit-suffixed marker only: a dossier quoting drovr's own "DROVR_EXIT:" literal must not
+        await driver.run(slot, `${adapter.headlessCommand(promptFile, cfg.consult.model)}; printf '\\nTICKMARKR_''EXIT:%s\\n' $?`);
+        // digit-suffixed marker only: a dossier quoting tickmarkr's own "TICKMARKR_EXIT:" literal must not
         // false-complete the consult pane before its verdict (same guard as daemon.ts:193 / llm.ts).
-        await driver.waitOutput(slot, "DROVR_EXIT:\\d", cfg.consult.stallMinutes * 60_000, { regex: true });
+        await driver.waitOutput(slot, "TICKMARKR_EXIT:\\d", cfg.consult.stallMinutes * 60_000, { regex: true });
         out = await driver.read(slot, 300);
         if (!opts.keep)
             await driver.close(slot);

package/dist/run/daemon.d.ts

@@ -18,6 +18,8 @@ export interface RunSummary {
     human: string[];
     pending: string[];
     blocked: string[];
+    tipVerify?: "passed" | "failed";
+    lastMergedTask?: string;
 }
 export declare function formatSummary(s: RunSummary): string;
 export declare function runDaemon(repoRoot: string, opts?: RunOptions): Promise<RunSummary>;

package/dist/run/daemon.js

@@ -14,13 +14,16 @@ import { consult } from "./consult.js";
 import { cleanupRunWorktrees, gitHead, sh } from "./git.js";
 import { Journal, loadRoutingProfile, newRunId } from "./journal.js";
 import { acquireRunLock, releaseRunLock } from "./lock.js";
-import { ensureIntegration, integrationBranch, integrationHead, mergeTask } from "./merge.js";
+import { ensureIntegration, integrationBranch, integrationHead, mergeTask, verifyIntegrationTip } from "./merge.js";
 import { nextChannel, route } from "../route/router.js";
 import { desiredPanes } from "./reconcile.js";
 // VIS-01: one formatter, four readers (run-end journal event, run/resume CLI, run-end notify).
 // Parity by construction — every caller renders the same complete bucket line.
 export function formatSummary(s) {
-    return `done: ${s.done.length}, failed: ${s.failed.length}, human: ${s.human.length}, blocked: ${s.blocked.length}, pending: ${s.pending.length}\nintegration branch: ${s.branch}`;
+    const tip = s.tipVerify === "failed"
+        ? `\ntip verify: FAILED${s.lastMergedTask ? ` (last merged: ${s.lastMergedTask})` : ""}`
+        : s.tipVerify === "passed" ? "\ntip verify: passed" : "";
+    return `done: ${s.done.length}, failed: ${s.failed.length}, human: ${s.human.length}, blocked: ${s.blocked.length}, pending: ${s.pending.length}\nintegration branch: ${s.branch}${tip}`;
 }
 const MAX_ATTEMPTS = 10; // ponytail: hard cap so a pathological ladder can never loop forever
 const BLOCKED_POLL_MS = 30_000; // between trailer-wait slices, check whether the pane is blocked on a prompt
@@ -50,7 +53,7 @@ export async function runDaemon(repoRoot, opts = {}) {
         const recordedBranch = typeof branchEvent?.data.branch === "string" ? branchEvent.data.branch : undefined;
         const branch = recordedBranch
             ? branchEvent.event === "merge" ? recordedBranch.slice(0, recordedBranch.lastIndexOf("--")) : recordedBranch
-            : opts.resume ? `drovr/${runId}` : integrationBranch(cfg, runId);
+            : integrationBranch(cfg, runId);
         if (lock.reclaimed)
             journal.append("lock-reclaimed", undefined, lock.reclaimed); // HARD-02 audit trail
         // GATE-08 (v1.12): the humanGate guard consults this run's journaled approvals, not just the compiled
@@ -124,14 +127,14 @@ export async function runDaemon(repoRoot, opts = {}) {
         };
         await reconcile(); // run start/resume boundary: nothing in flight — full sweep, incl. older runs' leftovers
         // v1.4 self-reference guard: a random nonce on the worker trailer AND exit marker. Displayed
-        // source/diffs (e.g. a worker editing drovr's own prompt.ts/daemon.ts) can't know it, so an echoed
-        // DROVR_RESULT/DROVR_EXIT literal can never premature-harvest the worker. Quote-split keeps the
+        // source/diffs (e.g. a worker editing tickmarkr's own prompt.ts/daemon.ts) can't know it, so an echoed
+        // TICKMARKR_RESULT/TICKMARKR_EXIT literal can never premature-harvest the worker. Quote-split keeps the
         // echoed command line itself from matching the marker it prints.
         //
         // v1.13 (VIS-09 safety, 43-02): the nonce is per-ATTEMPT, declared at the top of the attempt loop
         // below — NOT here at run scope. A run-scoped nonce is a latent hazard: HerdrDriver.read() is
         // `pane read --lines 1000` over scrollback and SubprocessDriver never clears s.buf, so any transcript
-        // retention across attempts would let attempt N harvest attempt N-1's DROVR_RESULT out of scrollback
+        // retention across attempts would let attempt N harvest attempt N-1's TICKMARKR_RESULT out of scrollback
         // as its OWN completion — silently LYING about a worker's outcome. Pinned by the stale-trailer oracle
         // in tests/run/daemon.test.ts ("a retained prior-attempt trailer cannot complete a retry"); a future
         // hoist back to run scope reddens it.
@@ -291,8 +294,8 @@ export async function runDaemon(repoRoot, opts = {}) {
                 // v1.13 (VIS-09 safety): one FRESH nonce per attempt — see the run-scope comment above. A retained
                 // prior-attempt trailer (herdr scrollback / subprocess buffer) must never satisfy this attempt.
                 const nonce = randomBytes(4).toString("hex");
-                const exitMarkerCmd = `printf '\\nDROVR_''EXIT_${nonce}:%s\\n' $?`;
-                const exitRe = new RegExp(`DROVR_EXIT_${nonce}:(\\d+)`);
+                const exitMarkerCmd = `printf '\\nTICKMARKR_''EXIT_${nonce}:%s\\n' $?`;
+                const exitRe = new RegExp(`TICKMARKR_EXIT_${nonce}:(\\d+)`);
                 if (attempt >= MAX_ATTEMPTS) {
                     await park(t, `attempt cap (${MAX_ATTEMPTS}) reached`, "attempt-cap", assignment, attempt, startMs, gateFails, consults, tokens, metered, retryMode);
                     return;
@@ -405,9 +408,9 @@ export async function runDaemon(repoRoot, opts = {}) {
                     while (Date.now() < deadline) {
                         const sliceStart = Date.now();
                         const slice = Math.min(BLOCKED_POLL_MS, deadline - sliceStart);
-                        if (await driver.waitOutput(slot, `(${trailerPattern(nonce)})|DROVR_EXIT_${nonce}:\\d`, slice, { regex: true })) {
-                            // verify before accepting: a worker that merely DISPLAYS a marker (e.g. editing drovr's
-                            // own source, where "DROVR_EXIT:" is a string literal) must not end the wait. Only a
+                        if (await driver.waitOutput(slot, `(${trailerPattern(nonce)})|TICKMARKR_EXIT_${nonce}:\\d`, slice, { regex: true })) {
+                            // verify before accepting: a worker that merely DISPLAYS a marker (e.g. editing tickmarkr's
+                            // own source, where "TICKMARKR_EXIT:" is a string literal) must not end the wait. Only a
                             // parseable trailer or a digit-suffixed exit marker in the harvest is completion.
                             output = await driver.read(slot, 1000); // TUI transcripts carry chrome — read deeper than print's 500
                             finished = new RegExp(trailerPattern(nonce)).test(output);
@@ -426,7 +429,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         const st = paged ? "" : await driver.status(slot);
                         if (!paged && (st === "blocked" || st === "idle")) {
                             // T5: once-per-slot auto-answer when the adapter declares a trust dialog and the pane
-                            // text matches. drovr created the worktree from the operator's own repo — safe by construction.
+                            // text matches. tickmarkr created the worktree from the operator's own repo — safe by construction.
                             if (!trustAnswered && adapter.trustDialog && driver.sendKey) {
                                 try {
                                     const paneText = await driver.read(slot, 80);
@@ -470,7 +473,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 else {
                     const inv = adapter.invoke(t, wt, assignment, { promptFile });
                     await driver.run(slot, `${inv.command}; ${exitMarkerCmd}`);
-                    finished = await driver.waitOutput(slot, `DROVR_EXIT_${nonce}:\\d`, cfg.taskTimeoutMinutes * 60_000, { regex: true });
+                    finished = await driver.waitOutput(slot, `TICKMARKR_EXIT_${nonce}:\\d`, cfg.taskTimeoutMinutes * 60_000, { regex: true });
                     output = await driver.read(slot, 500);
                     exitCode = Number(exitRe.exec(output)?.[1] ?? 1);
                 }
@@ -545,7 +548,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         return;
                     const g = e.result;
                     // GATE-09 (ROADMAP SC-4): journal every judge retry as an attributable event — which gate flaked,
-                    // which channel flaked, which channel retried — so `drovr journal`/report can distinguish "judge
+                    // which channel flaked, which channel retried — so `tickmarkr journal`/report can distinguish "judge
                     // flaked, retried" from "worker failed" (run-20260711-185020 P43-03 L70-72 billed a judge flake as
                     // a worker attempt; 47-01 fixed WHO retries, this closes the audit-trail half). The condition is
                     // META-ONLY (D-03): gate === "acceptance" + typeof-shape guards on meta.judgeRetry — never a
@@ -580,7 +583,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 // D-07: judge/review panes self-clean when their verdict is read (keepLlm) — only "forever" keeps them.
                                 keep: keepLlm,
                                 onSlot: keepLlm ? (s) => keptSlots.push(s) : undefined,
-                                // T2 ownership contract: canonical names (drovr:<role>:<task>:0:<runId>) so reconcile
+                                // T2 ownership contract: canonical names (tickmarkr:<role>:<task>:0:<runId>) so reconcile
                                 // owns judge/review panes; run-gates' -r1 retry suffix becomes attempt 1 in llm.ts.
                                 // Same-name reuse across worker attempts is safe: panes self-clean when read (keepLlm),
                                 // and herdr's DEFECT-01 reclaim covers a kept holdover under keepPanes:forever.
@@ -704,12 +707,37 @@ export async function runDaemon(repoRoot, opts = {}) {
             blocked: blockedTasks(graph).map((t) => t.id),
             pending: pendingTasks(graph).map((t) => t.id),
         };
+        // OBS-34: post-merge integration-tip verify — strict exit codes, no baseline forgiveness.
+        const lastMergedTask = [...journal.read()].reverse().find((e) => e.event === "merge" && e.taskId)?.taskId;
+        if (summary.done.length > 0 && Object.keys(commands).length > 0) {
+            const tipResults = await verifyIntegrationTip(intWt, commands);
+            let tipFailed = false;
+            for (const r of tipResults) {
+                if (r.pass) {
+                    journal.append("tip-verify", undefined, { gate: r.gate, cmd: r.cmd, pass: true, exitCode: r.exitCode, details: r.details });
+                }
+                else {
+                    journal.append("tip-verify-failed", undefined, {
+                        gate: r.gate,
+                        cmd: r.cmd,
+                        exitCode: r.exitCode,
+                        fingerprints: r.fingerprints,
+                        lastMergedTask,
+                    });
+                    tipFailed = true;
+                }
+            }
+            summary.tipVerify = tipFailed ? "failed" : "passed";
+            if (tipFailed && lastMergedTask)
+                summary.lastMergedTask = lastMergedTask;
+        }
         journal.append("run-end", undefined, { ...summary });
         await reconcile(); // run-end boundary: nothing in flight — full sweep (empty desired set)
         // OBS-28: lingering worktrees starve CLI probes; keepPanes:forever is the debug override.
         if (!keepForever) {
             const green = summary.failed.length === 0 && summary.human.length === 0
-                && summary.blocked.length === 0 && summary.pending.length === 0;
+                && summary.blocked.length === 0 && summary.pending.length === 0
+                && summary.tipVerify !== "failed";
             await cleanupRunWorktrees(repoRoot, branch, { removeIntegration: green, removeTaskIds: summary.done });
         }
         // VIS-02: name each blocked subtree by its nearest parked/failed root, e.g. "3 blocked behind P40-02".
@@ -717,7 +745,10 @@ export async function runDaemon(repoRoot, opts = {}) {
             .sort(([a], [b]) => a.localeCompare(b))
             .map(([root, count]) => `${count} blocked behind ${root}`)
             .join(", ");
-        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" });
+        const tipFail = summary.tipVerify === "failed"
+            ? ` — TIP VERIFY FAILED on ${summary.lastMergedTask ? `last merge ${summary.lastMergedTask}` : "integration tip"}`
+            : "";
+        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})` : ""}${tipFail} — integration branch ${branch} (merge to main is yours)`, { tier: summary.tipVerify === "failed" ? "attention" : "attention" });
         return summary;
     }
     finally {

package/dist/run/git.d.ts

@@ -14,6 +14,6 @@ export declare function cleanupRunWorktrees(repo: string, branch: string, opts:
     removeIntegration: boolean;
     removeTaskIds: string[];
 }): Promise<void>;
-export declare function resolveIntegrationBranch(repo: string, branch: string): Promise<string>;
+export declare function resolveIntegrationBranch(_repo: string, branch: string): Promise<string>;
 export declare function createWorktree(repo: string, branch: string, baseRef: string): Promise<string>;
 export declare function removeWorktree(repo: string, dir: string): Promise<void>;