tickmarkr 1.30.0 → 1.33.1

package/dist/graph/graph.js

@@ -24,7 +24,7 @@ export function drovrDir(repoRoot) {
 export function loadGraph(repoRoot) {
     const p = graphPath(repoRoot);
     if (!existsSync(p))
-        throw new Error(`no graph at ${p} — run \`drovr compile <src>\` first`);
+        throw new Error(`no graph at ${p} — run \`tickmarkr compile <src>\` first`);
     return validateGraph(JSON.parse(readFileSync(p, "utf8")));
 }
 export function saveGraph(repoRoot, g) {

package/dist/plan/prompt.js

@@ -1,9 +1,9 @@
 export function scopePrompt(intent, repair) {
     return `DROVR-JUDGE
-You are drafting a drovr native spec from an answered intent. Return only the Markdown spec, with no commentary or code fence.
+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:
-- start with <!-- drovr:spec -->
+- start with <!-- tickmarkr:spec -->
 - include a Requirements section whose ids are sequential REQ-01, REQ-02, ...
 - include an Assumptions section that makes every residual uncertainty explicit
 - include a Traceability section mapping every REQ-nn to at least one Tn task

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 } from "../compile/native.js";
+import { compileNative, NATIVE_MARKER } from "../compile/native.js";
 import { pickDriver } from "../drivers/index.js";
 import { extractJson, runLlm } from "../gates/llm.js";
 import { TaskSchema } from "../graph/schema.js";
@@ -64,12 +64,12 @@ function extractDraft(raw) {
     const fenced = [...clean.matchAll(/```(?:markdown|md)?\s*\n([\s\S]*?)```/gi)].at(-1)?.[1];
     if (fenced)
         return fenced;
-    const marker = clean.indexOf("<!-- drovr:spec");
+    const marker = clean.search(/<!--\s*(?:tickmarkr|drovr):spec/);
     return (marker === -1 ? clean : clean.slice(marker)).trimEnd() + "\n";
 }
 function validateDraft(draft) {
-    if (!/^<!--\s*drovr:spec(?:\s+v1)?\s*-->/m.test(draft))
-        throw new Error("draft is missing the drovr native marker");
+    if (!NATIVE_MARKER.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) ?? [])];

package/dist/run/consult.js

@@ -6,7 +6,7 @@ import { sh } from "./git.js";
 const ACTIONS = ["retry", "reroute", "decompose", "human"];
 export function buildDossierPrompt(d) {
     return `DROVR-CONSULT
-You are a senior engineering consult for the drovr orchestrator. A worker task hit trouble.
+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.
 
 ## Task: ${d.taskId} — trigger: ${d.trigger}

package/dist/run/daemon.js

@@ -38,9 +38,8 @@ export async function runDaemon(repoRoot, opts = {}) {
     // BEFORE loadGraph; release in the finally below (every exit path, incl. throws).
     const runId = opts.runId ?? newRunId();
     // T6 narrator: one live status surface per run (herdr only — driver.narrator is undefined on
-    // subprocess, so the optional-chain open below is a no-op there). Declared out here so the finally
-    // can close it on every exit path. Cosmetic-only: any failure is swallowed (never affects the run).
-    let narrator = null;
+    // subprocess, so the optional-chain open below is a no-op there). Cosmetic-only: any failure is
+    // swallowed (never affects the run); the operator closes a surviving watch pane.
     const lock = acquireRunLock(repoRoot, runId);
     try {
         let graph = loadGraph(repoRoot);
@@ -91,10 +90,10 @@ export async function runDaemon(repoRoot, opts = {}) {
         // show. driver.narrator is undefined on subprocess → no-op (subprocess spawns nothing). Swallowed:
         // a failed-to-open or later-dead watch pane never affects the run.
         try {
-            narrator = await driver.narrator?.(repoRoot, "drovr status --watch", runId) ?? null;
+            await driver.narrator?.(repoRoot, "tickmarkr status --watch", runId);
         }
         catch {
-            narrator = null; // cosmetic-only — the run proceeds without a live surface
+            /* cosmetic-only — the run proceeds without a live surface */
         }
         const intWt = await ensureIntegration(repoRoot, branch, baseRef);
         const concurrency = opts.concurrency ?? cfg.concurrency;
@@ -139,7 +138,7 @@ export async function runDaemon(repoRoot, opts = {}) {
         // merges are serialized — two concurrent `git merge`s in one worktree would corrupt each other
         let mergeChain = Promise.resolve();
         const mergeSerial = (taskBranch, t, gated) => {
-            const next = mergeChain.then(() => mergeTask(intWt, taskBranch, `drovr: merge ${t.id} ${t.title}`, gated));
+            const next = mergeChain.then(() => mergeTask(intWt, taskBranch, `tickmarkr: merge ${t.id} ${t.title}`, gated));
             mergeChain = next.catch(() => undefined);
             return next;
         };
@@ -153,7 +152,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 journal.telemetry({ taskId: t.id, shape: t.shape, adapter: assignment.adapter, model: assignment.model, channel: assignment.channel, attempts, outcome: "human", durationMs: Date.now() - startMs, parkKind: kind ?? undefined, gateFails, consults, tokens, meteredAttempts: tokens ? metered : undefined, retryMode });
             }
             await reconcile({ spareLiveLlm: true }); // task-human is a terminal event — sweep, sparing sibling tasks' live LLM panes
-            await driver.notify(`drovr ${runId}: ${t.id} needs a human — ${reason}`, { tier: "attention" });
+            await driver.notify(`tickmarkr ${runId}: ${t.id} needs a human — ${reason}`, { tier: "attention" });
         };
         const execTask = async (t) => {
             const startMs = Date.now();
@@ -252,7 +251,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     action: v.action, notes: v.notes,
                     ...(v.excludeAdapter ? { excludeAdapter: v.excludeAdapter } : {}),
                 });
-                await driver.notify(`drovr ${runId}: ${t.id} consult verdict: ${v.action}`, { tier: "attention" });
+                await driver.notify(`tickmarkr ${runId}: ${t.id} consult verdict: ${v.action}`, { tier: "attention" });
                 if (v.action === "retry") {
                     feedback = v.notes || feedback;
                     return true;
@@ -386,7 +385,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         threshold: cfg.contextWarnTokens,
                         attempt,
                     });
-                    await driver.notify(`drovr ${runId}: ${t.id} context ${usage.tokens} tokens ≥ ${cfg.contextWarnTokens}`, { tier: "attention" });
+                    await driver.notify(`tickmarkr ${runId}: ${t.id} context ${usage.tokens} tokens ≥ ${cfg.contextWarnTokens}`, { tier: "attention" });
                 };
                 let finished;
                 let output;
@@ -449,7 +448,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                             }
                             paged = true; // page once — the visible pane is the operator's to unblock; task timeout is the backstop
                             const why = st === "blocked" ? "is blocked on a prompt — approve in its pane" : "looks idle without finishing — check its pane";
-                            await driver.notify(`drovr ${runId}: ${slot.name} ${why}`, { tier: "attention" });
+                            await driver.notify(`tickmarkr ${runId}: ${slot.name} ${why}`, { tier: "attention" });
                         }
                         // a dead pane or a false-positive marker display returns fast — sleep the unspent slice, never hot-spin
                         const spent = Date.now() - sliceStart;
@@ -500,7 +499,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     const next = failover("quota-failover");
                     journal.append("quota-failover", t.id, { from: channelKey(assignment), to: next ? channelKey(next) : null });
                     if (next) {
-                        await driver.notify(`drovr ${runId}: ${t.id} quota failover`, { tier: "attention" });
+                        await driver.notify(`tickmarkr ${runId}: ${t.id} quota failover`, { tier: "attention" });
                         // OBS-17 T2: the superseded slot's pane closes AT REROUTE TIME — it holds a throttled
                         // dead-end, not failure context; the next safe-point reconcile catches a missed close.
                         if (!keepForever) {
@@ -562,7 +561,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                             });
                         }
                     }
-                    journal.append("gate-result", t.id, { gate: g.gate, pass: g.pass, details: g.details });
+                    journal.append("gate-result", t.id, { gate: g.gate, pass: g.pass, details: g.details, ...(g.meta?.skipped === true ? { skipped: true } : {}) });
                     // v1.1 failover: never re-ask a reviewer channel that produced garbage for this task
                     if (g.gate === "review" && !g.pass && /unparseable/.test(g.details) && typeof g.meta?.reviewer === "string") {
                         badReviewers.push(g.meta.reviewer);
@@ -642,7 +641,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 feedback = results.filter((g) => !g.pass).map((g) => `${g.gate}: ${g.details}`).join("\n\n");
                 const step = r.ladder[Math.min(ladderIdx++, r.ladder.length - 1)];
                 journal.append("escalation", t.id, { step, attempt: attempt + 1 });
-                await driver.notify(`drovr ${runId}: ${t.id} escalation: ${step}`, { tier: "attention" });
+                await driver.notify(`tickmarkr ${runId}: ${t.id} escalation: ${step}`, { tier: "attention" });
                 if (step === "retry")
                     continue;
                 if (step === "escalate") {
@@ -712,17 +711,10 @@ export async function runDaemon(repoRoot, opts = {}) {
             .sort(([a], [b]) => a.localeCompare(b))
             .map(([root, count]) => `${count} blocked behind ${root}`)
             .join(", ");
-        await driver.notify(`drovr ${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" });
+        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" });
         return summary;
     }
     finally {
-        // T6: close the narrator at run end — cosmetic, swallowed (never blocks lock release)
-        if (narrator) {
-            try {
-                await driver.close(narrator);
-            }
-            catch { /* cosmetic */ }
-        }
         releaseRunLock(repoRoot);
     }
 }

package/dist/run/git.js

@@ -7,14 +7,35 @@ import { drovrDir } from "../graph/graph.js";
 // (pi -p / codex exec wait for stdin EOF). timedOut distinguishes SIGKILL-timeout from a real nonzero exit.
 export function sh(cmd, cwd, timeoutMs = 600000) {
     return new Promise((resolve) => {
-        const p = spawn("bash", ["-lc", cmd], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        // detached: bash gets its own process group so a timeout can kill the whole tree —
+        // SIGKILLing bash alone orphans grandchildren (codex/pi) that hold the stdio pipes
+        // open, so "close" never fires and the promise wedges forever (v1.33.1 init hang).
+        const p = spawn("bash", ["-lc", cmd], { cwd, stdio: ["ignore", "pipe", "pipe"], detached: true });
         let stdout = "", stderr = "";
-        let timedOut = false;
-        const timer = setTimeout(() => { timedOut = true; p.kill("SIGKILL"); }, timeoutMs);
+        let timedOut = false, done = false;
+        const finish = (code, err) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            resolve({ code, stdout, stderr: err ?? stderr, timedOut });
+        };
+        const timer = setTimeout(() => {
+            timedOut = true;
+            try {
+                process.kill(-p.pid, "SIGKILL");
+            }
+            catch {
+                p.kill("SIGKILL");
+            }
+        }, timeoutMs);
         p.stdout.on("data", (d) => (stdout += d));
         p.stderr.on("data", (d) => (stderr += d));
-        p.on("error", (e) => { clearTimeout(timer); resolve({ code: 127, stdout, stderr: String(e), timedOut }); });
-        p.on("close", (code) => { clearTimeout(timer); resolve({ code: code ?? 1, stdout, stderr, timedOut }); });
+        p.on("error", (e) => finish(127, String(e)));
+        p.on("close", (code) => finish(code ?? 1));
+        // "close" waits for stdio to drain; a surviving pipe-holder must not outlive the timeout
+        p.on("exit", (code) => { if (timedOut)
+            finish(code ?? 1); });
     });
 }
 export async function shOk(cmd, cwd) {

package/dist/run/journal.d.ts

@@ -80,7 +80,9 @@ export declare class Journal {
     private constructor();
     static create(repoRoot: string, runId: string, narrate?: (event: JournalEvent) => void): Journal;
     static open(repoRoot: string, runId: string, narrate?: (event: JournalEvent) => void): Journal;
-    static latestRunId(repoRoot: string): string | null;
+    static latestRunId(repoRoot: string, opts?: {
+        withJournal?: boolean;
+    }): string | null;
     private get journalPath();
     append(event: string, taskId?: string, data?: Record<string, unknown>): void;
     read(): JournalEvent[];

package/dist/run/journal.js

@@ -157,10 +157,16 @@ export class Journal {
             throw new Error(`no journal for ${runId} at ${dir}`);
         return new Journal(dir, runId, narrate);
     }
-    static latestRunId(repoRoot) {
+    // withJournal: journal.jsonl appears at first append, after Journal.create mkdirs — a caller that
+    // will Journal.open the result (status, report) must fall back to the newest run that is actually
+    // readable, not throw on the mkdir-to-first-append window. Raw default stays for telemetry-scoped
+    // callers (profile cursor), where a journal-less run dir still counts.
+    static latestRunId(repoRoot, opts = {}) {
         if (!existsSync(runsDir(repoRoot)))
             return null;
-        const ids = readdirSync(runsDir(repoRoot)).filter((d) => d.startsWith("run-")).sort();
+        const ids = readdirSync(runsDir(repoRoot))
+            .filter((d) => d.startsWith("run-") && (!opts.withJournal || existsSync(join(runsDir(repoRoot), d, "journal.jsonl"))))
+            .sort();
         return ids.at(-1) ?? null;
     }
     get journalPath() {

package/dist/run/reconcile.js

@@ -88,6 +88,7 @@ export function desiredPanes(rows, runId) {
                 break;
             case "run-end":
                 desired.clear();
+                desired.add(formatOwnedName({ role: "watch", taskId: "run", attempt: 0, runId }));
                 break;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "1.30.0",
+  "version": "1.33.1",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",
@@ -9,12 +9,12 @@
   },
   "bin": {
     "tickmarkr": "dist/cli/index.js",
-    "drovr": "dist/cli/index.js",
-    "drover": "dist/cli/index.js"
+    "tkr": "dist/cli/index.js"
   },
   "files": [
     "dist",
-    "schema"
+    "schema",
+    "skills"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",

package/skills/tickmarkr-auto/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: tickmarkr-auto
+description: 'Run a repository’s requested specs autonomously with tickmarkr. Triggers: "/tickmarkr-auto", "run these specs with tickmarkr", "autonomous tickmarkr run".'
+argument-hint: "[spec-or-directory ...]"
+---
+
+# tickmarkr-auto — run repository specs autonomously
+
+Use this to execute a requested sequence of repository specs. It is SDD-agnostic: each target can be any file or directory accepted by `tickmarkr compile`.
+
+## Two-tier by default — role check before the loop
+
+When working in a multi-agent terminal environment, decide your role before starting:
+
+- **Orchestrator:** your session was started to execute the mission. Run the loop below.
+- **Supervisor with a live orchestrator:** do not start a second run. Relay the mission to the existing orchestrator with a verified send, then supervise it.
+- **Primary session without an orchestrator:** create one child orchestration session, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself.
+
+Outside a multi-agent terminal environment, run the loop directly.
+
+## Invariants
+
+- Never run two tickmarkr runs in the same repository concurrently.
+- Never let tickmarkr merge work to the main branch. New work consolidates on `tickmarkr/<runId>`.
+- Do not edit a generated graph to force an outcome; correct the source spec and compile again.
+- Gates independently verify evidence, scope, acceptance criteria, and review. A worker's completion claim is not evidence.
+- Treat missing or unparseable machine results and verdicts as failures. Never bypass a failed gate or merge partial work without a human decision.
+
+## Act by default
+
+Run every requested target in order without seeking routine confirmation. Stop only for a blocked agent interaction, a genuinely unresolved stalled task, a designed human gate, or a failed run that needs a human decision. Diagnose from the journal and evidence first; self-release and resume only after fixing and verifying a harness defect.
+
+## Per-spec loop
+
+1. **Prepare** — confirm the target list, check `git status`, confirm no tickmarkr run is active, and work from a non-main branch.
+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.
+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

@@ -0,0 +1,39 @@
+---
+name: tickmarkr-loop
+description: 'Run one repository spec autonomously with tickmarkr. Triggers: "/tickmarkr-loop", "run this spec with tickmarkr", "tickmarkr the spec".'
+---
+
+# tickmarkr-loop — run one spec autonomously
+
+Use this for any spec that `tickmarkr compile` accepts. It is SDD-agnostic: use the repository's requested spec format and keep the execution record beside that source spec.
+
+## Two-tier by default — role check before the loop
+
+When working in a multi-agent terminal environment, decide your role before starting:
+
+- **Orchestrator:** your session was started to execute the mission. Run the loop below.
+- **Supervisor with a live orchestrator:** do not start a second run. Relay the mission to the existing orchestrator with a verified send, then supervise it.
+- **Primary session without an orchestrator:** create one child orchestration session, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself.
+
+Outside a multi-agent terminal environment, run the loop directly.
+
+## Invariants
+
+- Never run two tickmarkr runs in the same repository concurrently.
+- Never let tickmarkr merge work to the main branch. New work consolidates on `tickmarkr/<runId>`.
+- Do not edit the compiled graph to force an outcome; fix the source spec and compile again.
+- Gates verify commits, diffs, acceptance criteria, and reviews independently. Never trust a worker's claim that work is complete.
+- Treat missing or unparseable machine results and verdicts as failures. Do not release, resume, or merge around failed gates.
+
+## Act by default
+
+Proceed through the loop without seeking routine confirmation. Stop only for a blocked agent interaction, a genuinely unresolved stalled task, or a designed human gate. Diagnose from the journal and available evidence before escalating; if a harness defect is fixed and verified, resume the run.
+
+## The loop
+
+1. **Prepare** — start from the requested spec. Check `git status`, confirm no tickmarkr run is active, and work from a non-main branch.
+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.
+6. **Record** — write `tickmarkr report <runId> --md` beside the source spec and commit the execution record when the repository tracks those records.