tickmarkr 1.37.0 → 1.38.0

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.js

@@ -53,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
@@ -127,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.
@@ -294,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;
@@ -408,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);
@@ -429,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);
@@ -473,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);
                 }
@@ -548,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
@@ -583,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.

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>;

package/dist/run/git.js

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 import { existsSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
 import { shq } from "../adapters/types.js";
-import { drovrDir } from "../graph/graph.js";
+import { tickmarkrDir } from "../graph/graph.js";
 // stdin "ignore": same class as HARD-05 / SubprocessDriver — never leave an open pipe a child can block on
 // (pi -p / codex exec wait for stdin EOF). timedOut distinguishes SIGKILL-timeout from a real nonzero exit.
 export function sh(cmd, cwd, timeoutMs = 600000) {
@@ -49,7 +49,7 @@ export async function gitHead(cwd) {
 }
 export const sanitizeBranch = (branch) => branch.replace(/[^\w.-]+/g, "-");
 const sanitize = sanitizeBranch;
-export const worktreePath = (repo, branch) => join(drovrDir(repo), "worktrees", sanitize(branch));
+export const worktreePath = (repo, branch) => join(tickmarkrDir(repo), "worktrees", sanitize(branch));
 /** OBS-28: remove this run's recorded worktrees; tolerates already-gone paths. */
 export async function cleanupRunWorktrees(repo, branch, opts) {
     if (opts.removeIntegration)
@@ -57,12 +57,8 @@ export async function cleanupRunWorktrees(repo, branch, opts) {
     for (const id of opts.removeTaskIds)
         await removeWorktree(repo, worktreePath(repo, `${branch}--${id}`));
 }
-const branchExists = async (repo, branch) => (await sh(`git rev-parse --verify ${shq(`refs/heads/${branch}`)}`, repo)).code === 0;
-export async function resolveIntegrationBranch(repo, branch) {
-    if (!branch.startsWith("drovr/"))
-        return branch;
-    const legacy = `drover/${branch.slice("drovr/".length)}`;
-    return !(await branchExists(repo, branch)) && await branchExists(repo, legacy) ? legacy : branch;
+export async function resolveIntegrationBranch(_repo, branch) {
+    return branch;
 }
 const resolveTaskBranch = async (repo, branch) => {
     const split = branch.lastIndexOf("--");
@@ -73,7 +69,7 @@ const resolveTaskBranch = async (repo, branch) => {
 };
 export async function createWorktree(repo, branch, baseRef) {
     branch = await resolveTaskBranch(repo, branch);
-    const dir = join(drovrDir(repo), "worktrees", sanitize(branch));
+    const dir = join(tickmarkrDir(repo), "worktrees", sanitize(branch));
     if (existsSync(dir))
         await removeWorktree(repo, dir);
     await shOk(`git worktree add -B ${shq(branch)} ${shq(dir)} ${shq(baseRef)}`, repo);

package/dist/run/journal.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { type Assignment } from "../adapters/types.js";
-import type { DrovrConfig } from "../config/config.js";
+import type { TickmarkrConfig } from "../config/config.js";
 import { type TaskStatus } from "../graph/schema.js";
 import { type RoutingProfile } from "../route/profile.js";
 export interface JournalEvent {
@@ -70,7 +70,7 @@ export declare function readAllTelemetry(repoRoot: string, lastK: number, opts?:
 })[];
 export declare const RUNS_WINDOW = 50;
 export declare function readProfileCursor(repoRoot: string): string | undefined;
-export declare function loadRoutingProfile(repoRoot: string, cfg: DrovrConfig, opts?: {
+export declare function loadRoutingProfile(repoRoot: string, cfg: TickmarkrConfig, opts?: {
     preview?: boolean;
 }): RoutingProfile | undefined;
 export declare class Journal {

package/dist/run/journal.js

@@ -123,8 +123,8 @@ export function readAllTelemetry(repoRoot, lastK, opts = {}) {
 }
 // ponytail: fixed 50-run window; promote to a routing.learned.* config knob only if operators need to tune it.
 export const RUNS_WINDOW = 50;
-// VIS-03 reset cursor — one trimmed runId line at .drovr/profile-since; absent/empty ⇒ undefined.
-// Opaque: used ONLY in the runId > comparison above, never a shell or path join beyond .drovr/.
+// VIS-03 reset cursor — one trimmed runId line at .tickmarkr/profile-since; absent/empty ⇒ undefined.
+// Opaque: used ONLY in the runId > comparison above, never a shell or path join beyond .tickmarkr/.
 export function readProfileCursor(repoRoot) {
     const path = join(repoRoot, stateDirName(repoRoot), "profile-since");
     if (!existsSync(path))
@@ -132,7 +132,7 @@ export function readProfileCursor(repoRoot) {
     return readFileSync(path, "utf8").trim() || undefined;
 }
 // The one shared profile builder (criterion 4: plan and daemon share ONE code path).
-// preview:true bypasses the routing.learned:off short-circuit so `drovr plan` can render the
+// preview:true bypasses the routing.learned:off short-circuit so `tickmarkr plan` can render the
 // trust-ramp preview while the daemon (no preview) stays inert (VALIDATION 13-01-11).
 export function loadRoutingProfile(repoRoot, cfg, opts = {}) {
     if (cfg.routing.learned === "off" && !opts.preview)
@@ -218,7 +218,7 @@ export class Journal {
     // lastAssignment} from EXISTING events only (task-dispatch + consult-verdict + optional v1.24
     // task-approved{release:attempt-cap}). Additive-only: no new required event, no schema change, the
     // status replay above is byte-untouched (corpus criterion 3 is git-diff-provable). Motivated by the
-    // 2026-07-11 incident (run-20260711-185020, P43-03): `drovr resume` re-dispatched at attempt 0 on
+    // 2026-07-11 incident (run-20260711-185020, P43-03): `tickmarkr resume` re-dispatched at attempt 0 on
     // pi:zai/glm-5.2, the exact channel a frontier consult had just banned, because execTask's
     // attempt/tried/assignment state is loop-local and dies with the process while the journal held every fact needed.
     //

package/dist/run/lock.js

@@ -1,14 +1,14 @@
 import { linkSync, readFileSync, statSync, unlinkSync, utimesSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
-import { drovrDir, stateDirName } from "../graph/graph.js";
-// HARD-01/02: coarse per-run advisory lock over .drovr/graph.json. LOCK-02: the lock is created by
+import { tickmarkrDir, stateDirName } from "../graph/graph.js";
+// HARD-01/02: coarse per-run advisory lock over .tickmarkr/graph.json. LOCK-02: the lock is created by
 // the link(2) idiom — write the full payload to graph.lock.<pid>.tmp, then linkSync(tmp, lockPath),
 // which is atomic and throws EEXIST if the lock already exists (the mutual-exclusion primitive).
 // rename() was REJECTED: it silently clobbers an existing destination, destroying that mutual
 // exclusion (two daemons would both "acquire"). LOCK-02 (OBS-05): a PROVABLY-dead holder (ESRCH)
 // self-clears immediately — expiry is NOT required. ESRCH is proof-positive death; the PID-reuse
-// hazard runs the OTHER way (a reused pid reads ALIVE and refuses until `drovr unlock`). mtime stays
+// hazard runs the OTHER way (a reused pid reads ALIVE and refuses until `tickmarkr unlock`). mtime stays
 // the heartbeat — it feeds the reclaim race guard (ino+mtime re-stat) and the reclaimed audit value.
 // Zero new deps — node:fs stdlib.
 export const HEARTBEAT_MS = 10_000;
@@ -16,7 +16,7 @@ export const STALE_MS = 60_000; // 6× heartbeat headroom; PITFALLS floor is ≥
 // T-10-01: the payload is a trust boundary — parse with zod, fail closed on garbage. Only
 // pid/runId/startedAt are ever read; anything else is ignored (info-disclosure surface).
 const PayloadSchema = z.object({ pid: z.number().int().positive(), runId: z.string(), startedAt: z.number() });
-const lockPath = (repoRoot) => join(drovrDir(repoRoot), "graph.lock");
+const lockPath = (repoRoot) => join(tickmarkrDir(repoRoot), "graph.lock");
 let heartbeat;
 let heldPath;
 // Best-effort release if the daemon exits without hitting its finally (crash mid-body). NO
@@ -33,12 +33,12 @@ process.once("exit", () => { if (heldPath)
 // `expired` for the race guard + reclaim audit); the heartbeat mechanism itself is untouched.
 // ponytail: a pid REUSED by an unrelated live process reads ALIVE (kill(pid,0) succeeds) and now
 // refuses indefinitely instead of expiring out in ≤60s — that is the fail-closed direction; the
-// escape hatch is `drovr unlock`. Acceptable for a single-machine tool (ESRCH is the only
+// escape hatch is `tickmarkr unlock`. Acceptable for a single-machine tool (ESRCH is the only
 // proof-positive death; narrowing further needs pid-start-time correlation, out of scope here).
 // LOCK-01: garbage ⇒ always refuse (mtime irrelevant). It short-circuits before dead can matter —
 // so inspect()'s `dead = pid === undefined` fallback for the garbage row stays harmless. Safe post-16-01:
-// the atomic link(2) write means drovr can no longer mint garbage itself; a garbage payload can only
-// come from external corruption, which is exactly what must refuse. Only `drovr unlock` removes it
+// the atomic link(2) write means tickmarkr can no longer mint garbage itself; a garbage payload can only
+// come from external corruption, which is exactly what must refuse. Only `tickmarkr unlock` removes it
 // — a self-heal reclaim would silently overwrite whatever corrupted the file.
 export function shouldRefuse(i) {
     return i.garbage || !i.dead;
@@ -49,7 +49,7 @@ function inspect(p) {
     const mtimeMs = st.mtimeMs;
     const expired = Date.now() - mtimeMs > STALE_MS;
     const parsed = PayloadSchema.safeParse(readPayload(p));
-    const garbage = !parsed.success; // LOCK-01: its own state — shouldRefuse refuses it unconditionally; only `drovr unlock` removes it
+    const garbage = !parsed.success; // LOCK-01: its own state — shouldRefuse refuses it unconditionally; only `tickmarkr unlock` removes it
     const pid = parsed.success ? parsed.data.pid : undefined;
     let dead = pid === undefined; // harmless fallback for the garbage row — garbage short-circuits shouldRefuse before this is read
     if (pid !== undefined) {
@@ -81,7 +81,7 @@ function unlinkIfOurs(p) {
 }
 export function acquireRunLock(repoRoot, runId) {
     const p = lockPath(repoRoot);
-    const tmp = join(drovrDir(repoRoot), `graph.lock.${process.pid}.tmp`);
+    const tmp = join(tickmarkrDir(repoRoot), `graph.lock.${process.pid}.tmp`);
     try {
         try {
             unlinkSync(tmp);
@@ -127,10 +127,10 @@ export function acquireRunLock(repoRoot, runId) {
         }
         const stateDir = stateDirName(repoRoot);
         if (garbage)
-            throw new Error(`${stateDir}/graph.lock holds an unreadable/garbage payload — refusing to reclaim it; run \`drovr unlock\` to remove it`);
+            throw new Error(`${stateDir}/graph.lock holds an unreadable/garbage payload — refusing to reclaim it; run \`tickmarkr unlock\` to remove it`);
         // LOCK-02: shouldRefuse is false whenever dead, so this throw is reached only for a LIVE holder
         // (incl. EPERM = alive-but-not-ours). The dead-but-fresh case self-clears via the reclaim branch.
-        throw new Error(`${stateDir}/graph.lock held by pid ${pid ?? "?"}${heldRun ? ` (run ${heldRun})` : ""} — another drovr run? (operator escape: \`drovr unlock\`)`);
+        throw new Error(`${stateDir}/graph.lock held by pid ${pid ?? "?"}${heldRun ? ` (run ${heldRun})` : ""} — another tickmarkr run? (operator escape: \`tickmarkr unlock\`)`);
     }
 }
 export function releaseRunLock(repoRoot) {

package/dist/run/merge.d.ts

@@ -1,4 +1,4 @@
-import type { DrovrConfig } from "../config/config.js";
+import type { TickmarkrConfig } from "../config/config.js";
 export interface TipVerifyResult {
     gate: string;
     cmd: string;
@@ -7,7 +7,7 @@ export interface TipVerifyResult {
     fingerprints: string[];
     details: string;
 }
-export declare function integrationBranch(cfg: DrovrConfig, runId: string): string;
+export declare function integrationBranch(cfg: TickmarkrConfig, runId: string): string;
 export declare function ensureIntegration(repo: string, branch: string, baseRef: string): Promise<string>;
 export declare function integrationHead(intWt: string): Promise<string>;
 export declare function mergeTask(intWt: string, taskBranch: string, message: string, gatedCommit: string): Promise<{

package/dist/run/merge.js

@@ -2,15 +2,15 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { shq } from "../adapters/types.js";
 import { fingerprint } from "../gates/baseline.js";
-import { drovrDir } from "../graph/graph.js";
+import { tickmarkrDir } from "../graph/graph.js";
 import { gitHead, resolveIntegrationBranch, sh, shOk } from "./git.js";
 export function integrationBranch(cfg, runId) {
-    return `tickmarkr/${runId}`;
+    return `${cfg.integrationBranchPrefix}${runId}`;
 }
 const sanitize = (branch) => branch.replace(/[^\w.-]+/g, "-");
 export async function ensureIntegration(repo, branch, baseRef) {
     branch = await resolveIntegrationBranch(repo, branch);
-    const dir = join(drovrDir(repo), "worktrees", sanitize(branch));
+    const dir = join(tickmarkrDir(repo), "worktrees", sanitize(branch));
     if (existsSync(join(dir, ".git")))
         return dir; // resume: keep existing tip
     const exists = (await sh(`git rev-parse --verify refs/heads/${shq(branch)}`, repo)).code === 0;

package/dist/run/reconcile.js

@@ -1,6 +1,6 @@
 import { formatOwnedName, isForeignName, panesToClose, parseOwnedName } from "../drivers/types.js";
 export { isForeignName, panesToClose, parseOwnedName };
-// T1: pure fold over journal rows — the exact set of drovr-owned pane/tab names that SHOULD exist
+// T1: pure fold over journal rows — the exact set of tickmarkr-owned pane/tab names that SHOULD exist
 // right now for a live run. No I/O: the caller supplies rows (Journal.read()) and a live pane listing
 // separately. Anything owned (parseOwnedName succeeds) but not in this set is garbage to close;
 // anything foreign (parseOwnedName fails) is never a candidate, no matter what state it's in.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "1.37.0",
+  "version": "1.38.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",
@@ -22,7 +22,7 @@
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "schema": "tsx scripts/emit-schema.ts",
-    "e2e": "DROVR_E2E=1 vitest run tests/e2e --testTimeout 900000"
+    "e2e": "TICKMARKR_E2E=1 vitest run tests/e2e --testTimeout 900000"
   },
   "dependencies": {
     "picomatch": "^4.0.2",