tickmarkr 1.36.0 → 1.38.0

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

@@ -12,7 +12,11 @@ export function formatJournalNarration({ event, taskId, data }) {
     const detail = Array.isArray(data.done)
         ? `done ${data.done.length}, failed ${Array.isArray(data.failed) ? data.failed.length : 0}`
         : typeof data.gate === "string"
-            ? `${data.gate}${data.pass === true ? " passed" : data.pass === false ? " failed" : ""}`
+            ? event === "tip-verify-failed"
+                ? `${data.gate} failed${typeof data.lastMergedTask === "string" ? ` after ${data.lastMergedTask}` : ""}`
+                : event === "tip-verify"
+                    ? `${data.gate} passed`
+                    : `${data.gate}${data.pass === true ? " passed" : data.pass === false ? " failed" : ""}`
             : typeof data.code === "number" ? `exit ${data.code}`
                 : typeof data.pid === "number" ? `pid ${data.pid}`
                     : typeof data.baseRef === "string" ? `base ${data.baseRef.slice(0, 12)}`
@@ -119,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))
@@ -128,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)
@@ -214,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,5 +1,13 @@
-import type { DrovrConfig } from "../config/config.js";
-export declare function integrationBranch(cfg: DrovrConfig, runId: string): string;
+import type { TickmarkrConfig } from "../config/config.js";
+export interface TipVerifyResult {
+    gate: string;
+    cmd: string;
+    pass: boolean;
+    exitCode: number;
+    fingerprints: string[];
+    details: 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<{
@@ -10,3 +18,4 @@ export declare function mergeTask(intWt: string, taskBranch: string, message: st
         branchTip: string;
     };
 }>;
+export declare function verifyIntegrationTip(intWt: string, commands: Record<string, string>): Promise<TipVerifyResult[]>;

package/dist/run/merge.js

@@ -1,15 +1,16 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { shq } from "../adapters/types.js";
-import { drovrDir } from "../graph/graph.js";
+import { fingerprint } from "../gates/baseline.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;
@@ -42,3 +43,20 @@ export async function mergeTask(intWt, taskBranch, message, gatedCommit) {
     await sh("git merge --abort", intWt);
     return { ok: false, conflict };
 }
+// OBS-34: strict exit-code verify on the integration tip — no baseline forgiveness.
+export async function verifyIntegrationTip(intWt, commands) {
+    const results = [];
+    for (const [gate, cmd] of Object.entries(commands)) {
+        const r = await sh(cmd, intWt);
+        const raw = (r.stdout + "\n" + r.stderr).split(intWt).join("");
+        results.push({
+            gate,
+            cmd,
+            pass: r.code === 0,
+            exitCode: r.code,
+            fingerprints: r.code !== 0 ? fingerprint(raw) : [],
+            details: r.code === 0 ? "exit 0" : `exit ${r.code}`,
+        });
+    }
+    return results;
+}

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.36.0",
+  "version": "1.38.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",
@@ -18,10 +18,11 @@
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "lint": "oxlint src tests scripts",
     "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",
@@ -32,6 +33,7 @@
     "@types/node": "^20.14.0",
     "@types/picomatch": "^4.0.0",
     "@vitest/coverage-v8": "^3.0.0",
+    "oxlint": "1.74.0",
     "tsx": "^4.19.0",
     "typescript": "^5.6.0",
     "vitest": "^3.0.0"

package/skills/tickmarkr-auto/SKILL.md

@@ -36,6 +36,6 @@ Run every requested target in order without seeking routine confirmation. Stop o
 2. **Compile** — run `tickmarkr compile <spec-or-directory>`. Fix source-spec defects instead of editing the generated graph.
 3. **Plan** — run `tickmarkr plan`. Review routes, capability-floor warnings, and human gates before execution.
 4. **Run** — run `tickmarkr run`. Watch the run journal for its terminal event rather than polling agents. Resolve blocked interactions in the relevant agent session.
-5. **Verify and consolidate** — continue only after a green run. Tickmarkr consolidates accepted work on `tickmarkr/<runId>` and never signs off to the main branch. A human controls any later release merge.
+5. **Verify and consolidate** — continue only after a green run. A run is green when the run-end event exists in the journal AND the tip verify is not "failed". Tickmarkr consolidates accepted work on `tickmarkr/<runId>` and never signs off to the main branch. A human controls any later release merge.
 6. **Record** — write `tickmarkr report <runId> --md` beside the source spec and commit the execution record when the repository tracks those records.
 7. **Continue** — move to the next requested target. If a target fails or is parked, stop with the journal evidence rather than silently skipping it.

package/skills/tickmarkr-loop/SKILL.md

@@ -35,5 +35,5 @@ Proceed through the loop without seeking routine confirmation. Stop only for a b
 2. **Compile** — run `tickmarkr compile <spec>`. Correct compilation errors in the spec, never in the generated graph.
 3. **Plan** — run `tickmarkr plan`. Review the routing table, capability-floor warnings, and every human gate, including work that each gate blocks.
 4. **Run** — run `tickmarkr run`. Watch the run journal for its terminal event rather than repeatedly polling agents. Resolve blocked interactions in the agent session; do not turn them into proxy questions.
-5. **Verify and consolidate** — accept only a green run. Tickmarkr consolidates accepted task work on `tickmarkr/<runId>`; it never signs off to the main branch. A human may later merge that integration branch through the repository's normal release process.
+5. **Verify and consolidate** — accept only a green run. A run is green when the run-end event exists in the journal AND the tip verify is not "failed". Tickmarkr consolidates accepted task work on `tickmarkr/<runId>`; it never signs off to the main branch. A human may later merge that integration branch through the repository's normal release process.
 6. **Record** — write `tickmarkr report <runId> --md` beside the source spec and commit the execution record when the repository tracks those records.