cursor-route 0.1.1 → 0.1.4

package/dist/jobs.js

@@ -0,0 +1,410 @@
+import { mkdirSync, writeFileSync, readFileSync, readdirSync, existsSync, unlinkSync, openSync, closeSync, chmodSync, } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { dirname } from "node:path";
+import { config, sessionName } from "./config.js";
+import { getAdapter } from "./adapters/index.js";
+import { spawn } from "node:child_process";
+import { spawnSync } from "node:child_process";
+import { createWorkerSession, sessionExists, killSession } from "./tmux.js";
+import { newJobId, shellQuote } from "./util.js";
+import { markCompleteInvoker } from "./runtime.js";
+import { assertJobId, JOB_ID_RE } from "./secrets.js";
+function ensureJobsDir() {
+    mkdirSync(config.jobsDir, { recursive: true, mode: 0o700 });
+    try {
+        chmodSync(config.jobsDir, 0o700);
+    }
+    catch {
+        /* ignore */
+    }
+}
+function writeSecure(path, data) {
+    writeFileSync(path, data, { mode: 0o600 });
+}
+function underJobsDir(id, ext) {
+    assertJobId(id);
+    const base = resolve(config.jobsDir);
+    const full = resolve(join(base, `${id}${ext}`));
+    if (!full.startsWith(base + "/") && full !== base) {
+        throw new Error("Job path escapes jobsDir");
+    }
+    return full;
+}
+export function jobPaths(id) {
+    ensureJobsDir();
+    return {
+        json: underJobsDir(id, ".json"),
+        prompt: underJobsDir(id, ".prompt"),
+        log: underJobsDir(id, ".log"),
+    };
+}
+export function readJob(id) {
+    try {
+        assertJobId(id);
+    }
+    catch {
+        return null;
+    }
+    const p = jobPaths(id).json;
+    if (!existsSync(p))
+        return null;
+    try {
+        return JSON.parse(readFileSync(p, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function writeJob(job) {
+    writeSecure(jobPaths(job.id).json, JSON.stringify(job, null, 2));
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+    }
+    catch {
+        return false;
+    }
+    // kill(pid, 0) stays true for zombies, and terminatePid's sync waits block the
+    // event loop so children can sit unreaped as zombies — a zombie is not a worker.
+    try {
+        const r = spawnSync("ps", ["-o", "state=", "-p", String(pid)], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        const state = (r.stdout || "").trim();
+        return state !== "" && !state.startsWith("Z");
+    }
+    catch {
+        return true;
+    }
+}
+function sleepMs(ms) {
+    spawnSync("sleep", [String(ms / 1000)]);
+}
+function terminatePid(pid) {
+    const trySignal = (sig, group) => {
+        try {
+            process.kill(group ? -pid : pid, sig);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    trySignal("SIGTERM", true);
+    trySignal("SIGTERM", false);
+    for (let i = 0; i < 10; i++) {
+        if (!pidAlive(pid))
+            return true;
+        sleepMs(100);
+    }
+    trySignal("SIGKILL", true);
+    trySignal("SIGKILL", false);
+    for (let i = 0; i < 10; i++) {
+        if (!pidAlive(pid))
+            return true;
+        sleepMs(100);
+    }
+    return !pidAlive(pid);
+}
+/** Refresh running jobs without inventing success from "session gone". */
+export function refreshStatus(job) {
+    if (job.status !== "running")
+        return job;
+    // Prefer completion-hook result if already written.
+    const fresh = readJob(job.id);
+    if (fresh && fresh.status !== "running")
+        return fresh;
+    const headless = job.tmuxSession.startsWith("headless-");
+    if (headless) {
+        if (job.pid && pidAlive(job.pid))
+            return job;
+        if (job.pid && !pidAlive(job.pid)) {
+            // Process exited but hook may not have run — mark unknown failure, not success.
+            const again = readJob(job.id);
+            if (again && again.status !== "running")
+                return again;
+            job.status = "failed";
+            job.error = job.error || "Headless worker exited without completion marker";
+            job.completedAt = new Date().toISOString();
+            writeJob(job);
+            return job;
+        }
+        // No pid recorded (legacy) — do not flip to completed.
+        return job;
+    }
+    // tmux path: session gone → re-read; if still running, mark failed (unknown), not completed.
+    if (!sessionExists(job.tmuxSession)) {
+        const again = readJob(job.id);
+        if (again && again.status !== "running")
+            return again;
+        job.status = "failed";
+        job.error = job.error || "tmux session ended without completion marker";
+        job.completedAt = new Date().toISOString();
+        writeJob(job);
+    }
+    return job;
+}
+export function countActiveJobs() {
+    ensureJobsDir();
+    let n = 0;
+    for (const f of readdirSync(config.jobsDir)) {
+        if (!f.endsWith(".json"))
+            continue;
+        const id = f.replace(/\.json$/, "");
+        if (!JOB_ID_RE.test(id))
+            continue;
+        try {
+            const job = JSON.parse(readFileSync(join(config.jobsDir, f), "utf8"));
+            if (job?.schema === "cursor-route.job.v1" && (job.status === "running" || job.status === "pending")) {
+                n++;
+            }
+        }
+        catch {
+            /* skip */
+        }
+    }
+    return n;
+}
+export function listJobs(limit = config.jobsListLimit) {
+    ensureJobsDir();
+    const files = readdirSync(config.jobsDir).filter((f) => f.endsWith(".json") && JOB_ID_RE.test(f.replace(/\.json$/, "")));
+    const jobs = [];
+    for (const f of files) {
+        try {
+            const job = JSON.parse(readFileSync(join(config.jobsDir, f), "utf8"));
+            if (job?.schema === "cursor-route.job.v1")
+                jobs.push(refreshStatus(job));
+        }
+        catch {
+            /* skip */
+        }
+    }
+    jobs.sort((a, b) => (a.createdAt < b.createdAt ? 1 : -1));
+    return jobs.slice(0, limit);
+}
+export function resolveWorker(opts) {
+    if (opts.worker)
+        return opts.worker;
+    if (opts.lane)
+        return config.laneWorkers[opts.lane];
+    return config.defaultWorker;
+}
+export function startJob(opts) {
+    const worker = resolveWorker(opts);
+    const cwd = opts.cwd || process.cwd();
+    // CURSOR_ROUTE_ASK applies to all workers; CLAUDE_DS_ASK is mid-lane only
+    const alwaysApprove = opts.alwaysApprove !== false &&
+        process.env.CURSOR_ROUTE_ASK !== "1" &&
+        !(worker === "claude-ds" && process.env.CLAUDE_DS_ASK === "1");
+    if (!opts.dryRun) {
+        const active = countActiveJobs();
+        if (active >= config.maxConcurrentJobs) {
+            return {
+                ok: false,
+                error: `Too many active jobs (${active} >= ${config.maxConcurrentJobs}) — wait for jobs to finish or raise CURSOR_ROUTE_MAX_JOBS`,
+            };
+        }
+    }
+    // Preflight: requested worker must be healthy
+    const adapter = getAdapter(worker);
+    const health = adapter.health();
+    if (!health.ok && !opts.dryRun) {
+        return { ok: false, error: `Worker ${worker} unavailable: ${health.detail}` };
+    }
+    const id = newJobId();
+    const paths = jobPaths(id);
+    writeSecure(paths.prompt, opts.prompt);
+    let plan;
+    try {
+        plan = adapter.buildLaunch({
+            promptFile: paths.prompt,
+            cwd,
+            alwaysApprove,
+        });
+    }
+    catch (e) {
+        try {
+            unlinkSync(paths.prompt);
+        }
+        catch {
+            /* ignore */
+        }
+        return { ok: false, error: e.message };
+    }
+    const job = {
+        id,
+        schema: "cursor-route.job.v1",
+        status: "pending",
+        worker,
+        lane: opts.lane,
+        prompt: opts.prompt,
+        cwd,
+        alwaysApprove: plan.alwaysApprove,
+        tmuxSession: opts.noTmux ? `headless-${id}` : sessionName(id),
+        createdAt: new Date().toISOString(),
+    };
+    if (opts.dryRun) {
+        // No durable prompt retention for dry-run
+        try {
+            unlinkSync(paths.prompt);
+        }
+        catch {
+            /* ignore */
+        }
+        const envNote = plan.env
+            ? ` (+env: ${Object.keys(plan.env).join(",")})`
+            : "";
+        return {
+            ok: true,
+            job,
+            dryRun: true,
+            command: plan.command + envNote,
+        };
+    }
+    const here = dirname(fileURLToPath(import.meta.url));
+    const markComplete = join(here, "mark-complete.ts");
+    const invoker = markCompleteInvoker(markComplete);
+    // Persist running BEFORE launch so fast workers cannot race completion overwrite.
+    job.status = "running";
+    job.startedAt = new Date().toISOString();
+    writeJob(job);
+    if (opts.noTmux) {
+        const wrapped = [
+            plan.command,
+            `exit_code=$?`,
+            `${invoker} ${shellQuote(paths.json)} "$exit_code" ${shellQuote(paths.log)}`,
+            `exit $exit_code`,
+        ].join("; ");
+        let logFd;
+        try {
+            logFd = openSync(paths.log, "a", 0o600);
+        }
+        catch (e) {
+            job.status = "failed";
+            job.error = `Cannot open log: ${e.message}`;
+            job.completedAt = new Date().toISOString();
+            writeJob(job);
+            return { ok: false, error: job.error };
+        }
+        const child = spawn("sh", ["-c", wrapped], {
+            cwd,
+            detached: true,
+            stdio: ["ignore", logFd, logFd],
+            env: plan.env ? { ...process.env, ...plan.env } : process.env,
+        });
+        try {
+            closeSync(logFd);
+        }
+        catch {
+            /* ignore */
+        }
+        if (child.pid == null) {
+            job.status = "failed";
+            job.error = "Failed to spawn headless worker";
+            job.completedAt = new Date().toISOString();
+            writeJob(job);
+            return { ok: false, error: job.error };
+        }
+        // Merge-on-write: only set pid if still running (avoid clobbering mark-complete)
+        const latest = readJob(id) || job;
+        if (latest.status === "running" || latest.status === "pending") {
+            latest.pid = child.pid;
+            writeJob(latest);
+            Object.assign(job, latest);
+        }
+        child.unref();
+        return { ok: true, job };
+    }
+    const created = createWorkerSession({
+        jobId: id,
+        cwd,
+        workerCmd: plan.command,
+        logFile: paths.log,
+        jobFile: paths.json,
+        markCompleteScript: markComplete,
+        env: plan.env,
+    });
+    if (!created.ok) {
+        job.status = "failed";
+        job.error = created.error;
+        job.completedAt = new Date().toISOString();
+        writeJob(job);
+        return { ok: false, error: created.error };
+    }
+    // Re-read before final write — mark-complete may have already finished
+    const after = readJob(id) || job;
+    if (after.status === "running" || after.status === "pending") {
+        writeJob(after);
+    }
+    return { ok: true, job: after };
+}
+export function killJob(id) {
+    const job = readJob(id);
+    if (!job)
+        return { ok: false, error: `Job not found: ${id}` };
+    if (job.status === "completed" || job.status === "failed" || job.status === "killed") {
+        return { ok: false, error: `Job already terminal (${job.status}) — refuse kill rewrite` };
+    }
+    if (job.tmuxSession.startsWith("headless-")) {
+        if (job.pid) {
+            const ok = terminatePid(job.pid);
+            if (!ok) {
+                return { ok: false, error: `Failed to kill pid ${job.pid}` };
+            }
+        }
+        else {
+            return {
+                ok: false,
+                error: "Headless job has no pid — cannot kill (legacy job). Kill the worker process manually.",
+            };
+        }
+    }
+    else {
+        const killed = killSession(job.tmuxSession);
+        if (!killed && sessionExists(job.tmuxSession)) {
+            return { ok: false, error: `Failed to kill tmux session ${job.tmuxSession}` };
+        }
+    }
+    // Merge-on-write: do not clobber a completion that landed mid-kill
+    const latest = readJob(id) || job;
+    if (latest.status === "completed" || latest.status === "failed") {
+        return { ok: false, error: `Job finished during kill (${latest.status})` };
+    }
+    latest.status = "killed";
+    latest.completedAt = new Date().toISOString();
+    writeJob(latest);
+    return { ok: true, job: latest };
+}
+export function cleanJobs(olderThanDays = 7) {
+    ensureJobsDir();
+    const cutoff = Date.now() - olderThanDays * 86400000;
+    let n = 0;
+    for (const f of readdirSync(config.jobsDir)) {
+        if (!f.endsWith(".json"))
+            continue;
+        const id = f.replace(/\.json$/, "");
+        if (!JOB_ID_RE.test(id))
+            continue;
+        try {
+            const job = JSON.parse(readFileSync(join(config.jobsDir, f), "utf8"));
+            const t = Date.parse(job.completedAt || job.createdAt);
+            if (Number.isFinite(t) &&
+                t < cutoff &&
+                (job.status === "completed" || job.status === "failed" || job.status === "killed")) {
+                for (const ext of [".json", ".prompt", ".log"]) {
+                    const fp = underJobsDir(id, ext);
+                    if (existsSync(fp))
+                        unlinkSync(fp);
+                }
+                n++;
+            }
+        }
+        catch {
+            /* skip */
+        }
+    }
+    return n;
+}

package/dist/mark-complete.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env bun
+/**
+ * Marks a job completed/failed after the worker process exits.
+ * Invoked from tmux / headless completion hooks — keep dep-free.
+ */
+import { readFileSync, writeFileSync } from "node:fs";
+import { redactSecrets } from "./secrets.js";
+const jobPath = process.argv[2];
+const exitCode = Number(process.argv[3] ?? "1");
+const logPath = process.argv[4];
+if (!jobPath)
+    process.exit(0);
+try {
+    const job = JSON.parse(readFileSync(jobPath, "utf8"));
+    if (job.status === "running" || job.status === "pending") {
+        job.status = exitCode === 0 ? "completed" : "failed";
+        job.exitCode = exitCode;
+        job.completedAt = new Date().toISOString();
+        if (exitCode !== 0 && !job.error) {
+            job.error = `Worker exited with code ${exitCode}`;
+        }
+        if (logPath) {
+            try {
+                const log = readFileSync(logPath, "utf8");
+                job.logBytes = Buffer.byteLength(log);
+                job.logTail = redactSecrets(log).slice(-2000);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        writeFileSync(jobPath, JSON.stringify(job, null, 2), { mode: 0o600 });
+    }
+}
+catch {
+    /* never fail the shell hook hard */
+}
+process.exit(0);

package/dist/runtime.js

@@ -0,0 +1,27 @@
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+import { commandExists, shellQuote } from "./util.js";
+/**
+ * Resolve how to re-invoke the completion hook (mark-complete) from shell hooks.
+ * Prefer compiled dist via node (no loader); else Bun on src. No npx/tsx on the
+ * happy path — surface a clear failure if neither is available.
+ */
+export function markCompleteInvoker(scriptPath) {
+    const compiled = scriptPath.replace(/\.ts$/, ".js");
+    if (existsSync(compiled)) {
+        return `node ${shellQuote(compiled)}`;
+    }
+    if (commandExists("bun")) {
+        return `bun ${shellQuote(scriptPath)}`;
+    }
+    return `sh -c 'echo "cursor-route: completion hook needs a compiled dist or Bun (run bun run build)" >&2; exit 1'`;
+}
+/** XDG-ish default away from git-clone install dir (~/.cursor-route). */
+export function defaultJobsDir() {
+    if (process.env.CURSOR_ROUTE_JOBS_DIR)
+        return process.env.CURSOR_ROUTE_JOBS_DIR;
+    const home = process.env.HOME || homedir();
+    const xdg = process.env.XDG_DATA_HOME || join(home, ".local", "share");
+    return join(xdg, "cursor-route", "jobs");
+}

package/dist/secrets.js

@@ -0,0 +1,39 @@
+/**
+ * Secret material detectors — match key *contents*, not the phrase "API key".
+ * Applied to `start` and `send`, and reused for log-tail redaction.
+ */
+export const SECRET_PATTERNS = [
+    // OpenAI / DeepSeek legacy + project / Anthropic hyphenated keys
+    /\bsk-[a-zA-Z0-9]{20,}\b/,
+    /\bsk-(?:proj|ant|oai)-[A-Za-z0-9_-]{16,}\b/,
+    /\bsk-[a-zA-Z0-9-]{20,}\b/,
+    /\bghp_[A-Za-z0-9]{20,}\b/,
+    /\bgho_[A-Za-z0-9]{20,}\b/,
+    /\bgithub_pat_[A-Za-z0-9_]{20,}\b/,
+    /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/i,
+    /\bxai-[A-Za-z0-9_-]{20,}\b/,
+    /\bAIza[0-9A-Za-z_-]{20,}\b/,
+    /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----/,
+    /\bAKIA[0-9A-Z]{16}\b/,
+    /hooks\.slack\.com\/services\/[A-Za-z0-9/_-]+/i,
+];
+export function looksLikeSecretMaterial(text) {
+    return SECRET_PATTERNS.some((re) => re.test(text));
+}
+/** Redact secret-looking spans for job metadata / log tails. */
+export function redactSecrets(text) {
+    let out = text;
+    for (const re of SECRET_PATTERNS) {
+        // Clone with global flag so we replace all matches
+        const flags = re.flags.includes("g") ? re.flags : `${re.flags}g`;
+        out = out.replace(new RegExp(re.source, flags), "[REDACTED]");
+    }
+    return out;
+}
+export const JOB_ID_RE = /^[a-f0-9]{8}$/;
+export function assertJobId(id) {
+    if (!JOB_ID_RE.test(id)) {
+        throw new Error(`Invalid job id: ${id} (expected 8 hex chars)`);
+    }
+    return id;
+}

package/dist/tmux.js

@@ -0,0 +1,117 @@
+import { spawnSync, execSync } from "node:child_process";
+import { config, sessionName } from "./config.js";
+import { shellQuote } from "./util.js";
+import { markCompleteInvoker } from "./runtime.js";
+export function isTmuxAvailable() {
+    try {
+        execSync("command -v tmux", { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function sessionExists(name) {
+    try {
+        execSync(`tmux has-session -t ${shellQuote(name)} 2>/dev/null`, {
+            stdio: "ignore",
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function listManagedSessions() {
+    try {
+        const out = execSync('tmux list-sessions -F "#{session_name}" 2>/dev/null', {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (!out)
+            return [];
+        return out.split("\n").filter((n) => n.startsWith(`${config.tmuxPrefix}-`));
+    }
+    catch {
+        return [];
+    }
+}
+export function capturePane(name, lines = 50) {
+    try {
+        return execSync(`tmux capture-pane -t ${shellQuote(name)} -p -S -${Math.max(1, lines)}`, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    }
+    catch {
+        return "";
+    }
+}
+export function sendKeys(name, message) {
+    if (!sessionExists(name))
+        return false;
+    // Reject embedded newlines — they would submit early even with -l
+    if (/[\r\n]/.test(message))
+        return false;
+    try {
+        // -l = literal keys (so "C-c" types text, does not SIGINT the worker)
+        execSync(`tmux send-keys -l -t ${shellQuote(name)} -- ${shellQuote(message)}`, { stdio: "ignore" });
+        spawnSync("sleep", ["0.25"]);
+        execSync(`tmux send-keys -t ${shellQuote(name)} Enter`, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function killSession(name) {
+    try {
+        execSync(`tmux kill-session -t ${shellQuote(name)}`, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function attachHint(jobId) {
+    return `tmux attach -t ${sessionName(jobId)}`;
+}
+/**
+ * Create a detached tmux session that runs `workerCmd` via `sh -c` under `script`,
+ * then marks the job complete and exits the session.
+ * Always quote the shell expression so macOS BSD `script` does not split `cd && …`.
+ */
+export function createWorkerSession(options) {
+    const name = sessionName(options.jobId);
+    const isLinux = process.platform === "linux";
+    const invoker = markCompleteInvoker(options.markCompleteScript);
+    const completion = [
+        `exit_code=$?`,
+        `${invoker} ${shellQuote(options.jobFile)} "$exit_code" ${shellQuote(options.logFile)}`,
+        `echo ""`,
+        `echo "[cursor-route: session complete — closing in 5s]"`,
+        `sleep 5`,
+        `tmux kill-session -t ${shellQuote(name)} 2>/dev/null || true`,
+    ].join("; ");
+    // Always run workerCmd under sh -c so `cd … && …` stays one expression.
+    // Linux script: script -q -e -c '<cmd>' <logfile>
+    // macOS script: script -q <logfile> <cmd> <args...>
+    const wrapped = isLinux
+        ? `script -q -e -c ${shellQuote(`/bin/sh -c ${shellQuote(options.workerCmd)}`)} ${shellQuote(options.logFile)}; ${completion}`
+        : `script -q ${shellQuote(options.logFile)} /bin/sh -c ${shellQuote(options.workerCmd)}; ${completion}`;
+    const args = ["new-session", "-d", "-s", name, "-c", options.cwd];
+    if (options.env) {
+        for (const [k, v] of Object.entries(options.env)) {
+            args.push("-e", `${k}=${v}`);
+        }
+    }
+    args.push(wrapped);
+    const r = spawnSync("tmux", args, {
+        encoding: "utf8",
+        cwd: options.cwd,
+    });
+    if (r.status !== 0) {
+        return {
+            ok: false,
+            error: (r.stderr || r.stdout || "tmux new-session failed").toString().trim(),
+        };
+    }
+    return { ok: true, session: name };
+}

package/dist/util.js

@@ -0,0 +1,21 @@
+import { spawnSync } from "node:child_process";
+/** Shell-escape a string for single-quoted POSIX use. */
+export function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+/** Short job id (8 hex chars). */
+export function newJobId() {
+    const bytes = crypto.getRandomValues(new Uint8Array(4));
+    return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+export function commandExists(cmd) {
+    try {
+        const r = spawnSync("sh", ["-c", `command -v ${shellQuote(cmd)}`], {
+            encoding: "utf8",
+        });
+        return r.status === 0 && Boolean(r.stdout?.trim());
+    }
+    catch {
+        return false;
+    }
+}

package/docs/DEMO_GIF.md

@@ -3,10 +3,14 @@
 tmux is required for the viral attach/send demo. On this laptop brew needs sudo — record after:
 
 ```bash
-brew install tmux
-export PATH="$HOME/.cursor-route/bin:$PATH"
+# tmux may live at ~/.local/bin/tmux (already on PATH in this setup); otherwise:
+# brew install tmux
+command -v tmux
 cursor-route health
 
+# Jobs live under the XDG data dir, not a git clone:
+# ~/.local/share/cursor-route/jobs  (override: CURSOR_ROUTE_JOBS_DIR)
+
 # Terminal A — three parallel jobs
 cursor-route start --lane hard --dir "$PWD" "Add README section Demo"
 cursor-route start --lane mid --dir "$PWD" "Add a unit test for shellQuote"
@@ -17,6 +21,9 @@ cursor-route jobs --json
 # Attach one pane for the GIF: tmux attach -t cursor-route-<id>
 ```
 
+If you previously exported `$HOME/.cursor-route/bin`, that dir is stale — remove it:
+`rm -rf ~/.cursor-route/bin` (the launcher lives in the installed package, not there).
+
 Record with [asciinema](https://asciinema.org/) or CleanShot → export GIF → `docs/fixtures/hero.gif`.
 
 Until then, use `docs/fixtures/claude-ds-smoke.log` as the committed proof fixture.