pr-shepherd 0.8.1 → 0.10.0

package/bin/github/http.mjs

@@ -1,5 +1,7 @@
 import { execFile as execFileCb } from "node:child_process";
 import { promisify } from "node:util";
+import { appendEntry, nextEntry } from "../log/log-file.mjs";
+import { formatRequestEntry, formatResponseEntry } from "../log/session.mjs";
 const execFile = promisify(execFileCb);
 const BASE_URL = "https://api.github.com";
 // ---------------------------------------------------------------------------
@@ -42,33 +44,87 @@ async function makeHeaders() {
 function sanitizeBody(body) {
     return body.replace(/Bearer\s+\S+/gi, "[REDACTED]").slice(0, 200);
 }
-async function requestWithTokenRetry(fn) {
+function redactToken(body) {
+    return body.replace(/Bearer\s+\S+/gi, "[REDACTED]");
+}
+function redactUrl(url) {
+    try {
+        const u = new URL(url);
+        return `${u.origin}${u.pathname}`;
+    }
+    catch {
+        return url;
+    }
+}
+async function requestWithTokenRetry(fn, t0, onIntermediate) {
     const res = await fn();
     if (res.status === 401 && _token !== undefined) {
+        onIntermediate?.(401, Math.round(performance.now() - t0));
         try {
             await res.arrayBuffer();
         }
         catch { }
         _token = undefined;
-        return fn();
+        const retryT0 = performance.now();
+        return { res: await fn(), attempt: 2, retryT0 };
     }
-    return res;
+    return { res, attempt: 1, retryT0: t0 };
 }
 // ---------------------------------------------------------------------------
 // GraphQL
 // ---------------------------------------------------------------------------
 async function graphqlInner(query, vars) {
-    const res = await requestWithTokenRetry(async () => fetch(`${BASE_URL}/graphql`, {
+    const url = `${BASE_URL}/graphql`;
+    const n = nextEntry();
+    appendEntry(formatRequestEntry({
+        n,
+        kind: "GraphQL",
+        method: "POST",
+        url,
+        body: { query, variables: vars },
+    }));
+    const t0 = performance.now();
+    const { res, attempt, retryT0 } = await requestWithTokenRetry(async () => fetch(url, {
         method: "POST",
         headers: await makeHeaders(),
         body: JSON.stringify({ query, variables: vars }),
-    }));
+    }), t0, (status, firstDurationMs) => {
+        appendEntry(formatResponseEntry({
+            n,
+            kind: "GraphQL",
+            method: "POST",
+            url,
+            status,
+            durationMs: firstDurationMs,
+        }));
+    });
+    const durationMs = Math.round(performance.now() - retryT0);
     const rateLimit = parseRateLimit(res.headers);
     if (!res.ok) {
         const body = await res.text();
+        appendEntry(formatResponseEntry({
+            n,
+            kind: "GraphQL",
+            method: "POST",
+            url,
+            status: res.status,
+            durationMs,
+            textBody: redactToken(body),
+            attempt: attempt > 1 ? attempt : undefined,
+        }));
         throw new Error(`GitHub GraphQL request failed: ${res.status} ${sanitizeBody(body)}`);
     }
     const parsed = (await res.json());
+    appendEntry(formatResponseEntry({
+        n,
+        kind: "GraphQL",
+        method: "POST",
+        url,
+        status: res.status,
+        durationMs,
+        body: parsed,
+        attempt: attempt > 1 ? attempt : undefined,
+    }));
     if (parsed.data == null) {
         const messages = (parsed.errors ?? []).map((e) => e.message).join("; ");
         throw new Error(`GitHub GraphQL error (no data): ${messages}`);
@@ -91,31 +147,109 @@ export async function graphqlWithRateLimit(query, vars = {}) {
 // REST
 // ---------------------------------------------------------------------------
 export async function rest(method, path, body) {
-    const res = await requestWithTokenRetry(async () => fetch(`${BASE_URL}${path}`, {
+    const url = `${BASE_URL}${path}`;
+    const n = nextEntry();
+    appendEntry(formatRequestEntry({ n, kind: "REST", method, url, body }));
+    const t0 = performance.now();
+    const { res, attempt, retryT0 } = await requestWithTokenRetry(async () => fetch(url, {
         method,
         headers: await makeHeaders(),
         body: body !== undefined ? JSON.stringify(body) : undefined,
-    }));
+    }), t0, (status, firstDurationMs) => {
+        appendEntry(formatResponseEntry({ n, kind: "REST", method, url, status, durationMs: firstDurationMs }));
+    });
+    const durationMs = Math.round(performance.now() - retryT0);
+    const ct = res.headers.get("content-type") ?? "";
     if (!res.ok) {
         const text = await res.text();
+        appendEntry(formatResponseEntry({
+            n,
+            kind: "REST",
+            method,
+            url,
+            status: res.status,
+            durationMs,
+            textBody: redactToken(text),
+            attempt: attempt > 1 ? attempt : undefined,
+        }));
         throw new Error(`GitHub REST ${method} ${path} failed: ${res.status} ${sanitizeBody(text)}`);
     }
-    const ct = res.headers.get("content-type") ?? "";
     if (ct.includes("application/json")) {
-        return res.json();
+        const json = (await res.json());
+        appendEntry(formatResponseEntry({
+            n,
+            kind: "REST",
+            method,
+            url,
+            status: res.status,
+            durationMs,
+            contentType: ct,
+            body: json,
+            attempt: attempt > 1 ? attempt : undefined,
+        }));
+        return json;
     }
+    appendEntry(formatResponseEntry({
+        n,
+        kind: "REST",
+        method,
+        url,
+        status: res.status,
+        durationMs,
+        contentType: ct || undefined,
+        attempt: attempt > 1 ? attempt : undefined,
+    }));
     return undefined;
 }
 export async function restText(path) {
-    const res = await requestWithTokenRetry(async () => fetch(`${BASE_URL}${path}`, {
+    const url = `${BASE_URL}${path}`;
+    const n = nextEntry();
+    appendEntry(formatRequestEntry({ n, kind: "restText", method: "GET", url }));
+    const t0 = performance.now();
+    const { res, attempt, retryT0 } = await requestWithTokenRetry(async () => fetch(url, {
         method: "GET",
         headers: await makeHeaders(),
         redirect: "manual",
-    }));
+    }), t0, (status, firstDurationMs) => {
+        appendEntry(formatResponseEntry({
+            n,
+            kind: "restText",
+            method: "GET",
+            url,
+            status,
+            durationMs: firstDurationMs,
+        }));
+    });
+    const durationMs = Math.round(performance.now() - retryT0);
     if (res.status === 301 || res.status === 302 || res.status === 307 || res.status === 308) {
+        appendEntry(formatResponseEntry({
+            n,
+            kind: "restText",
+            method: "GET",
+            url,
+            status: res.status,
+            durationMs,
+            attempt: attempt > 1 ? attempt : undefined,
+        }));
         const location = res.headers.get("location");
         if (location) {
+            const n2 = nextEntry();
+            const logUrl = redactUrl(location);
+            appendEntry(formatRequestEntry({ n: n2, kind: "restText", method: "GET", url: logUrl }));
+            const t1 = performance.now();
             const redirectRes = await fetch(location);
+            const duration2 = Math.round(performance.now() - t1);
+            const clRaw = redirectRes.headers.get("content-length");
+            const contentLength = clRaw !== null && Number.isFinite(Number(clRaw)) ? Number(clRaw) : undefined;
+            appendEntry(formatResponseEntry({
+                n: n2,
+                kind: "restText",
+                method: "GET",
+                url: logUrl,
+                status: redirectRes.status,
+                durationMs: duration2,
+                contentLength,
+            }));
             if (!redirectRes.ok) {
                 throw new Error(`redirect target ${location} failed: ${redirectRes.status}`);
             }
@@ -124,8 +258,29 @@ export async function restText(path) {
     }
     if (!res.ok) {
         const text = await res.text();
+        appendEntry(formatResponseEntry({
+            n,
+            kind: "restText",
+            method: "GET",
+            url,
+            status: res.status,
+            durationMs,
+            attempt: attempt > 1 ? attempt : undefined,
+        }));
         throw new Error(`GitHub REST GET ${path} failed: ${res.status} ${sanitizeBody(text)}`);
     }
+    const clRaw = res.headers.get("content-length");
+    const contentLength = clRaw !== null && Number.isFinite(Number(clRaw)) ? Number(clRaw) : undefined;
+    appendEntry(formatResponseEntry({
+        n,
+        kind: "restText",
+        method: "GET",
+        url,
+        status: res.status,
+        durationMs,
+        contentLength,
+        attempt: attempt > 1 ? attempt : undefined,
+    }));
     return res.text();
 }
 // ---------------------------------------------------------------------------

package/bin/github/queries.mjs

@@ -1,23 +1,19 @@
 /**
  * GraphQL query strings used by pr-shepherd.
  *
- * Query strings live in src/github/gql/*.gql.
- * Never inline raw GraphQL strings in .ts source files.
+ * Static query strings live in src/github/gql/*.gql and are loaded here.
+ * Dynamic documents whose content varies per call (e.g. BulkApply in
+ * src/comments/resolve.mts) are built at runtime and are exempt — they
+ * cannot be expressed as static files.
  */
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 const gql = (name) => readFileSync(join(import.meta.dirname, "gql", name), "utf8");
 /** The primary batch query that fetches CI + comments + merge status in one round-trip. */
 export const BATCH_PR_QUERY = gql("batch-pr.gql");
-/** Resolve a single review thread. */
-export const RESOLVE_THREAD_MUTATION = gql("resolve-thread.gql");
-/** Minimize a PR comment (IssueComment). */
-export const MINIMIZE_COMMENT_MUTATION = gql("minimize-comment.gql");
-/** Dismiss a pull request review. */
-export const DISMISS_REVIEW_MUTATION = gql("dismiss-review.gql");
-/** Multi-PR status query for `shepherd status PR1 PR2 …`. */
-export const MULTI_PR_STATUS_QUERY = gql("multi-pr-status.gql");
-/** Paginated version — used when reviewThreads is truncated (totalCount > 100). */
+/** Returns the current head commit SHA for a PR. Used by waitForSha polling. */
+export const GET_PR_HEAD_SHA_QUERY = gql("get-pr-head-sha.gql");
+/** Paginated follow-up for `shepherd status` — used when reviewThreads is truncated (totalCount > 100). */
 export const MULTI_PR_STATUS_QUERY_WITH_CURSOR = gql("multi-pr-status-paged.gql");
 /** Look up PR number by branch name (for getCurrentPrNumber). */
 export const PR_NUMBER_BY_BRANCH_QUERY = gql("pr-number-by-branch.gql");

package/bin/log/log-file.mjs

@@ -0,0 +1,88 @@
+/**
+ * Append-only per-worktree markdown log.
+ *
+ * Log path: $PR_SHEPHERD_STATE_DIR/<owner>-<repo>/worktrees/<basename>-<sha8>.md
+ *
+ * Always-on by default. Set PR_SHEPHERD_LOG_DISABLED=1 or CI=true to disable.
+ * Write failures flip an internal disabled flag so the CLI never crashes because
+ * logging failed.
+ */
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { resolveStateBase } from "../state/base.mjs";
+import { SAFE_SEGMENT } from "../util/path-segment.mjs";
+import { getWorktreeKey } from "../util/worktree.mjs";
+function computeDisabled() {
+    if (process.env["PR_SHEPHERD_LOG_DISABLED"] === "1")
+        return true;
+    const ci = process.env["CI"];
+    return ci !== undefined && ci !== "" && ci !== "0" && ci !== "false";
+}
+let _disabled = computeDisabled();
+let _logPath = null;
+let _entryCounter = 0;
+/** Returns the next monotonically-increasing entry number for the current session. */
+export function nextEntry() {
+    return ++_entryCounter;
+}
+export function getLogFilePath(key) {
+    const { owner, repo } = key;
+    if (!SAFE_SEGMENT.test(owner) || !SAFE_SEGMENT.test(repo)) {
+        throw new Error(`Invalid repo key segments: ${owner}/${repo}`);
+    }
+    const base = resolveStateBase();
+    // Worktree key injected at init time; fall back to "unknown" if not yet set.
+    const wkey = _worktreeKey ?? "unknown";
+    return join(base, `${owner}-${repo}`, "worktrees", `${wkey}.md`);
+}
+let _worktreeKey = null;
+/**
+ * Initialize the log for this process. Must be called before appendEntry().
+ * Silently disables logging on any error (no git repo, bad repo name, etc.).
+ */
+export async function initLog(repoKey) {
+    if (_disabled)
+        return null;
+    try {
+        const { owner, repo } = repoKey;
+        if (!SAFE_SEGMENT.test(owner) || !SAFE_SEGMENT.test(repo))
+            return null;
+        _worktreeKey = await getWorktreeKey();
+        const path = getLogFilePath(repoKey);
+        mkdirSync(dirname(path), { recursive: true });
+        _logPath = path;
+        return path;
+    }
+    catch {
+        _disabled = true;
+        return null;
+    }
+}
+/** Append a pre-formatted markdown chunk to the log. No-op if disabled. */
+export function appendEntry(markdown) {
+    if (_disabled || _logPath === null)
+        return;
+    try {
+        appendFileSync(_logPath, markdown);
+    }
+    catch (e) {
+        process.stderr.write(`pr-shepherd: log write failed (disabling log): ${String(e)}\n`);
+        _disabled = true;
+    }
+}
+/** Resolve the log path without initializing (for the log-file subcommand). */
+export async function resolveLogPath(repoKey) {
+    if (!SAFE_SEGMENT.test(repoKey.owner) || !SAFE_SEGMENT.test(repoKey.repo)) {
+        throw new Error(`Invalid repo key segments: ${repoKey.owner}/${repoKey.repo}`);
+    }
+    const wkey = await getWorktreeKey();
+    const base = resolveStateBase();
+    return join(base, `${repoKey.owner}-${repoKey.repo}`, "worktrees", `${wkey}.md`);
+}
+/** Exposed for tests to reset module state. */
+export function _resetLogState() {
+    _disabled = computeDisabled();
+    _logPath = null;
+    _worktreeKey = null;
+    _entryCounter = 0;
+}

package/bin/log/session.mjs

@@ -0,0 +1,100 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+function readVersion() {
+    const pkgUrl = new URL("../../package.json", import.meta.url);
+    const pkg = JSON.parse(readFileSync(fileURLToPath(pkgUrl), "utf8"));
+    return pkg.version;
+}
+/** Builds the session header markdown block. */
+export function buildSessionHeader(argv) {
+    const ts = new Date().toISOString();
+    const cmd = argv.slice(2).join(" ") || "(no args)";
+    const markdown = `## ${ts} — pr-shepherd ${cmd}\n\n` + `pid: ${process.pid} · version: ${readVersion()}\n\n`;
+    return { markdown };
+}
+const _maxBodyRaw = Number(process.env["PR_SHEPHERD_LOG_MAX_BODY"]);
+const MAX_BODY = Number.isFinite(_maxBodyRaw) && _maxBodyRaw > 0 ? _maxBodyRaw : 256 * 1024;
+function truncate(s) {
+    if (s.length <= MAX_BODY)
+        return s;
+    return `${s.slice(0, MAX_BODY)}\n...[truncated ${s.length - MAX_BODY} characters]`;
+}
+function fenceBody(body, lang) {
+    const raw = typeof body === "string" ? body : JSON.stringify(body);
+    return `\`\`\`${lang}\n${truncate(raw)}\n\`\`\`\n`;
+}
+function extractOperationName(query) {
+    const match = /^\s*(?:query|mutation|subscription)\s+(\w+)/m.exec(query);
+    return match?.[1] ?? "(anonymous)";
+}
+export function formatRequestEntry(entry) {
+    const ts = new Date().toISOString();
+    const label = entry.kind === "GraphQL"
+        ? `GraphQL request — POST ${entry.url}`
+        : entry.kind === "restText"
+            ? `restText request — GET ${entry.url}`
+            : `REST request — ${entry.method} ${entry.url}`;
+    let out = `### #${entry.n} ${label} · ${ts}\n\n`;
+    if (entry.kind === "restText") {
+        out += `(body omitted: log artifact)\n\n`;
+        return out;
+    }
+    if (entry.body !== undefined && entry.kind === "GraphQL") {
+        const { query, variables } = entry.body;
+        out += `operation: \`${extractOperationName(query)}\`\n`;
+        if (variables && Object.keys(variables).length > 0) {
+            out += `variables:\n${fenceBody(variables, "json")}`;
+        }
+        else {
+            // For dynamic documents (e.g. BulkApply) the IDs are inlined as aliases.
+            // Count the aliases so the log shows how many operations were batched.
+            const aliasCount = (query.match(/^\s+[_A-Za-z]\w*:/gm) ?? []).length;
+            if (aliasCount > 0)
+                out += `aliases: ${aliasCount}\n`;
+        }
+    }
+    else if (entry.body !== undefined) {
+        out += fenceBody(entry.body, "json");
+    }
+    else {
+        out += `(no body)\n`;
+    }
+    return out + "\n";
+}
+export function formatResponseEntry(entry) {
+    const ts = new Date().toISOString();
+    const attempt = entry.attempt !== undefined ? ` (attempt ${entry.attempt}/2 after 401)` : "";
+    const label = entry.kind === "GraphQL"
+        ? `GraphQL response — ${entry.status}${attempt} · ${entry.durationMs}ms`
+        : entry.kind === "restText"
+            ? `restText response — ${entry.status}${attempt} · ${entry.durationMs}ms`
+            : `REST response — ${entry.status}${attempt} · ${entry.durationMs}ms`;
+    let out = `### #${entry.n} ${label} · ${ts}\n\n`;
+    if (entry.kind === "restText") {
+        if (entry.contentLength !== undefined) {
+            out += `content-length: ${entry.contentLength} bytes (body not logged)\n\n`;
+        }
+        else {
+            out += `(body not logged)\n\n`;
+        }
+        return out;
+    }
+    if (entry.contentType !== undefined) {
+        out += `content-type: ${entry.contentType}`;
+        if (entry.contentLength !== undefined)
+            out += ` · ${entry.contentLength} bytes`;
+        out += "\n";
+    }
+    if (entry.body !== undefined) {
+        out += fenceBody(entry.body, "json");
+    }
+    else if (entry.textBody !== undefined) {
+        out += fenceBody(entry.textBody, "");
+    }
+    return out + "\n";
+}
+export function formatOutputEntry(text, format) {
+    const ts = new Date().toISOString();
+    const lang = format === "json" ? "json" : "";
+    return `### Output (${format}) · ${ts}\n\n${fenceBody(text.trimEnd(), lang)}\n`;
+}

package/bin/log/setup.mjs

@@ -0,0 +1,54 @@
+import { initLog, appendEntry } from "./log-file.mjs";
+import { buildSessionHeader, formatOutputEntry } from "./session.mjs";
+import { getRepoInfo } from "../github/client.mjs";
+let _done = false;
+function detectFormat(argv) {
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === "--format=json")
+            return "json";
+        if (argv[i] === "--format" && argv[i + 1] === "json")
+            return "json";
+    }
+    return "text";
+}
+/**
+ * Initialize the per-worktree log, write the session header, and install a
+ * stdout tee that routes all CLI output to the log. No-op after the first call.
+ * Silently skips logging when not in a git repo or on any other error.
+ */
+export async function setupLog(argv) {
+    if (_done)
+        return;
+    _done = true;
+    try {
+        const { owner, name } = await getRepoInfo();
+        const log = await initLog({ owner, repo: name });
+        if (!log)
+            return;
+    }
+    catch {
+        return;
+    }
+    try {
+        const { markdown: header } = buildSessionHeader(argv);
+        appendEntry(header);
+        const format = detectFormat(argv);
+        const origWrite = process.stdout.write.bind(process.stdout);
+        process.stdout.write = (chunk, encodingOrCb, cb) => {
+            try {
+                const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+                if (text.length > 0)
+                    appendEntry(formatOutputEntry(text, format));
+            }
+            catch {
+                // Best-effort: logging must never interfere with CLI output.
+            }
+            return typeof encodingOrCb === "function"
+                ? origWrite(chunk, encodingOrCb)
+                : origWrite(chunk, encodingOrCb, cb);
+        };
+    }
+    catch {
+        // Best-effort: logging setup must never prevent the CLI from running.
+    }
+}

package/bin/reporters/agent.mjs

@@ -7,39 +7,47 @@
  * detailsUrl is preserved in AgentCheck as a fallback for external status checks.
  * The original domain types are preserved for check command output.
  */
+import { extractSuggestion } from "../suggestions/extract.mjs";
 export function toAgentThread(t) {
-    return { id: t.id, path: t.path, line: t.line, author: t.author, body: t.body };
+    const suggestion = extractSuggestion(t) ?? undefined;
+    return {
+        id: t.id,
+        path: t.path,
+        line: t.line,
+        ...(t.line !== null &&
+            t.startLine !== null &&
+            t.startLine !== t.line && { startLine: t.startLine }),
+        author: t.author,
+        body: t.body,
+        url: t.url,
+        ...(suggestion !== undefined && { suggestion }),
+    };
 }
 export function toAgentComment(c) {
-    return { id: c.id, author: c.author, body: c.body };
+    return { id: c.id, author: c.author, body: c.body, url: c.url };
 }
 export function toAgentCheck(c) {
     return {
         name: c.name,
         runId: c.runId,
         detailsUrl: c.detailsUrl,
-        failureKind: c.failureKind,
         ...(c.workflowName !== undefined && { workflowName: c.workflowName }),
+        ...(c.jobName !== undefined && { jobName: c.jobName }),
         ...(c.failedStep !== undefined && { failedStep: c.failedStep }),
         ...(c.summary !== undefined && { summary: c.summary }),
+        ...(c.logTail !== undefined && { logTail: c.logTail }),
     };
 }
 /**
- * Project and deduplicate checks so the agent makes one `gh run view` call
- * per run (dedup by runId) and skips duplicate external status checks (dedup
- * by name when runId is null).
+ * Project failing checks for the agent. Deduplicates only null-runId external
+ * checks by name — when runId is present each check may have a distinct job and
+ * log tail, so they are all kept.
  */
 export function toAgentChecks(checks) {
-    const seenRunIds = new Set();
     const seenNames = new Set();
     const result = [];
     for (const c of checks) {
-        if (c.runId !== null) {
-            if (seenRunIds.has(c.runId))
-                continue;
-            seenRunIds.add(c.runId);
-        }
-        else {
+        if (c.runId === null) {
             if (seenNames.has(c.name))
                 continue;
             seenNames.add(c.name);

package/bin/reporters/check-instructions.mjs

@@ -26,20 +26,15 @@ export function buildCheckInstructions(report) {
     }
     // 3. CI budget policy — one instruction per failing check
     for (const c of checks.failing) {
-        if (c.failureKind === "actionable") {
-            const diagnosisHint = c.failedStep
-                ? `the failure was in step \`${c.failedStep}\` — fetch the run log with \`gh run view ${c.runId ?? "<runId>"} --log-failed\` to diagnose`
-                : c.runId
-                    ? `fetch the run log with \`gh run view ${c.runId} --log-failed\` to diagnose the failure`
-                    : `open the check details (${c.detailsUrl}) to diagnose the failure`;
-            instructions.push(`Fix code failure: \`${c.name}\` (actionable) — ${diagnosisHint} and apply a fix.`);
-        }
-        else if (c.failureKind === "cancelled" || c.failureKind === "timeout") {
-            const rerunCmd = c.runId
-                ? `gh run rerun ${c.runId} --failed`
-                : `gh run rerun <runId> --failed`;
-            instructions.push(`Re-run transient failure: \`${c.name}\` [${c.failureKind}] — run \`${rerunCmd}\`.`);
-        }
+        const stepHint = c.failedStep ? ` (failed step: \`${c.failedStep}\`)` : "";
+        const diagnosisHint = c.runId
+            ? c.logTail !== undefined
+                ? `examine the log tail${stepHint} — if transient, run \`gh run rerun ${c.runId} --failed\`; otherwise apply a fix`
+                : `run \`gh run view ${c.runId} --log-failed\`${stepHint} to diagnose — if transient, rerun with \`gh run rerun ${c.runId} --failed\`; otherwise apply a fix`
+            : c.detailsUrl
+                ? `open the check details (${c.detailsUrl}) to diagnose the failure`
+                : `no run or details URL available — escalate to a human`;
+        instructions.push(`Failing check: \`${c.name}\` — ${diagnosisHint}.`);
     }
     // 4. Ready-to-merge gate
     const isClean = mergeStatus.mergeStateStatus === "CLEAN";