pr-shepherd 0.44.0 → 0.45.0

package/bin/log/session.d.mts

@@ -24,6 +24,17 @@ interface HttpResponseEntry {
     contentLength?: number;
     /** Set on 401-retry invocations. */
     attempt?: number;
+    authSource?: string;
+    rateLimit?: {
+        resource?: string;
+        limit: number;
+        used?: number;
+        remaining: number;
+        resetAt: number;
+        cost?: number;
+        nodeCount?: number;
+    };
+    retryAfterSeconds?: number;
 }
 export declare function formatRequestEntry(entry: HttpRequestEntry): string;
 export declare function formatResponseEntry(entry: HttpResponseEntry): string;

package/bin/log/session.mjs

@@ -70,6 +70,28 @@ export function formatResponseEntry(entry) {
             ? `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.authSource !== undefined)
+        out += `auth-source: \`${entry.authSource}\`\n`;
+    if (entry.rateLimit !== undefined) {
+        const used = entry.rateLimit.used !== undefined ? ` · used ${entry.rateLimit.used}` : "";
+        const resource = entry.rateLimit.resource ?? "unknown";
+        out += `rate-limit: \`${resource}\` · remaining ${entry.rateLimit.remaining}/${entry.rateLimit.limit}${used} · reset ${new Date(entry.rateLimit.resetAt * 1000).toISOString()}\n`;
+        if (entry.rateLimit.cost !== undefined || entry.rateLimit.nodeCount !== undefined) {
+            const parts = [
+                entry.rateLimit.cost !== undefined ? `cost ${entry.rateLimit.cost}` : null,
+                entry.rateLimit.nodeCount !== undefined ? `nodes ${entry.rateLimit.nodeCount}` : null,
+            ].filter(Boolean);
+            out += `graphql-query: ${parts.join(" · ")}\n`;
+        }
+    }
+    if (entry.retryAfterSeconds !== undefined) {
+        out += `retry-after: ${entry.retryAfterSeconds}s\n`;
+    }
+    if (entry.authSource !== undefined ||
+        entry.rateLimit !== undefined ||
+        entry.retryAfterSeconds !== undefined) {
+        out += "\n";
+    }
     if (entry.kind === "restText") {
         if (entry.contentLength !== undefined) {
             out += `content-length: ${entry.contentLength} bytes (body not logged)\n\n`;

package/bin/mcp/server.mjs

@@ -6,6 +6,7 @@ import { createPrShepherd, PartialApplyError, PrShepherdValidationError, } from
 import { isRepositoryQualifiedPrReference } from "../pr-reference.mjs";
 import { formatJournalResult } from "../cli/journal-formatter.mjs";
 import { formatCommitSuggestionResult, formatSuggestionPatchesResult, formatIterateResult, formatMarkFilesAsViewedResult, formatMutateResult, } from "../cli/formatters.mjs";
+import { formatCliError, serializeGitHubRequestErrorDetails } from "../cli/error-format.mjs";
 import { errorToExitCode, EXIT } from "../exit-codes.mjs";
 const QUALIFIED_PR_ERROR = "pr must be a GitHub pull-request URL or an owner/repo#number reference";
 const pr = z
@@ -166,16 +167,29 @@ function toolError(error) {
         : error instanceof PartialApplyError
             ? errorToExitCode(error.cause)
             : errorToExitCode(error);
+    const cause = error instanceof PartialApplyError ? error.cause : error;
+    const githubDetails = serializeGitHubRequestErrorDetails(cause);
     const details = error instanceof PartialApplyError
         ? { failedIndex: error.failedIndex, completed: redactValue(error.completed) }
         : error instanceof PrShepherdValidationError
             ? { validation: true }
             : {};
-    const message = redactErrorMessage(error instanceof Error ? error.message : String(error));
+    const formattedCause = formatCliError(cause);
+    const causeMessage = cause instanceof Error ? cause.message : String(cause);
+    const message = redactErrorMessage(error instanceof PartialApplyError && formattedCause.startsWith(causeMessage)
+        ? `${error.message}${formattedCause.slice(causeMessage.length)}`
+        : formattedCause);
     return {
         isError: true,
         content: [{ type: "text", text: `pr-shepherd error (${code}): ${message}` }],
-        structuredContent: { code, message, details },
+        structuredContent: {
+            code,
+            message,
+            details: {
+                ...details,
+                ...(githubDetails !== undefined && { github: redactValue(githubDetails) }),
+            },
+        },
     };
 }
 function redactErrorMessage(message) {

package/bin/quota-warning.d.mts

@@ -0,0 +1,2 @@
+import type { GraphqlQuotaWarning } from "./types.mts";
+export declare function buildQuotaAwareContinuation(warning: GraphqlQuotaWarning, prefix: string): string;

package/bin/quota-warning.mjs

@@ -0,0 +1,6 @@
+export function buildQuotaAwareContinuation(warning, prefix) {
+    const interval = `${warning.pollIntervalMinutes}m`;
+    const timeout = `${warning.pollTimeoutMinutes}m`;
+    const resetTime = new Date(warning.resetAt * 1000).toISOString();
+    return `${prefix} GitHub's GraphQL API quota is low (crossed the ${warning.thresholdPercent}% remaining threshold). For the time being, prefer non-GraphQL \`gh\` CLI commands (e.g. \`gh pr view\`, \`gh pr checks\`, \`gh pr review\`, \`gh api\` REST endpoints) for PR operations — they draw on the separate REST budget, not the depleted GraphQL pool. Resume pr-shepherd after the GraphQL quota resets at ${resetTime}. If you must keep polling before then, poll no more often than every ${warning.pollIntervalMinutes} minutes. With a polling CLI command, preserve the other options, replace any existing interval and timeout flags with \`--interval ${interval} --timeout ${timeout}\`, and omit \`--timeout\` when using \`--until-terminal\`. With a single-tick CLI, API, or MCP call, wait at least ${warning.pollIntervalMinutes} minutes before the next tick.`;
+}

package/bin/state/graphql-quota-claims.d.mts

@@ -0,0 +1,2 @@
+import type { GraphqlQuotaWarning } from "../types.mts";
+export declare function claimWarning(path: string, warning: GraphqlQuotaWarning, now: number, rearmEpoch: number): Promise<boolean>;

package/bin/state/graphql-quota-claims.mjs

@@ -0,0 +1,61 @@
+import { mkdir, open, readdir, unlink } from "node:fs/promises";
+import { join } from "node:path";
+export async function claimWarning(path, warning, now, rearmEpoch) {
+    const claimsDir = `${path}.claims`;
+    const claimPath = join(claimsDir, `${warning.resetAt}-${warning.limit}-${warning.thresholdPercent}-${rearmEpoch}.json`);
+    let handle;
+    try {
+        await mkdir(claimsDir, { recursive: true });
+        await sweepStaleClaims(claimsDir, now);
+        handle = await open(claimPath, "wx");
+        await handle.writeFile(JSON.stringify({
+            resource: warning.resource,
+            resetAt: warning.resetAt,
+            thresholdPercent: warning.thresholdPercent,
+            rearmEpoch,
+        }), "utf8");
+        return true;
+    }
+    catch (error) {
+        // When state storage is unavailable, surfacing the warning is safer than
+        // silently exhausting the credential. EEXIST alone means another process
+        // racing for this exact re-arm epoch already won the claim — a claim
+        // left over from an earlier epoch (e.g. before a credential switch) has
+        // a different filename and never collides here, so a re-armed warning
+        // is never suppressed by a stale epoch's claim.
+        return !isAlreadyExists(error);
+    }
+    finally {
+        try {
+            await handle?.close();
+        }
+        catch {
+            // Best-effort claim cleanup is unnecessary: existence is the claim.
+        }
+    }
+}
+async function sweepStaleClaims(claimsDir, now) {
+    try {
+        const entries = await readdir(claimsDir);
+        await Promise.all(entries.map(async (entry) => {
+            const resetAt = Number(entry.split("-")[0]);
+            if (!Number.isFinite(resetAt) || now < resetAt)
+                return;
+            try {
+                await unlink(join(claimsDir, entry));
+            }
+            catch {
+                // Best-effort sweep.
+            }
+        }));
+    }
+    catch {
+        // Best-effort sweep; a missing or unreadable directory is fine.
+    }
+}
+function isAlreadyExists(error) {
+    return (error !== null &&
+        typeof error === "object" &&
+        "code" in error &&
+        error.code === "EEXIST");
+}

package/bin/state/graphql-quota-policy.d.mts

@@ -0,0 +1,17 @@
+import type { GraphqlQuotaWarningBand } from "../config/load.mts";
+import type { GraphqlApiUsage, GraphqlQuotaWarning } from "../types.mts";
+export interface GraphqlQuotaWarningState {
+    resource: string;
+    limit: number;
+    lastUsed?: number;
+    lastRemaining: number;
+    resetAt: number;
+    warnedThresholds: number[];
+    rearmEpoch?: number;
+}
+export declare function evaluateGraphqlQuotaWarning(bands: GraphqlQuotaWarningBand[], sample: Pick<GraphqlApiUsage, "resource" | "limit" | "used" | "remaining" | "resetAt">, previous: GraphqlQuotaWarningState | null, observedAt?: number): {
+    warning?: GraphqlQuotaWarning;
+    state: GraphqlQuotaWarningState & {
+        rearmEpoch: number;
+    };
+};

package/bin/state/graphql-quota-policy.mjs

@@ -0,0 +1,43 @@
+export function evaluateGraphqlQuotaWarning(bands, sample, previous, observedAt = Date.now() / 1000) {
+    const windowRolled = previous !== null && sample.resetAt > previous.resetAt && observedAt >= previous.resetAt;
+    const rearm = previous === null ||
+        previous.resource !== sample.resource ||
+        previous.limit !== sample.limit ||
+        windowRolled ||
+        (sample.used !== undefined && previous.lastUsed !== undefined
+            ? sample.used < previous.lastUsed
+            : sample.remaining > previous.lastRemaining);
+    const warned = new Set(rearm ? [] : previous.warnedThresholds);
+    const rearmEpoch = rearm ? (previous?.rearmEpoch ?? 0) + 1 : (previous?.rearmEpoch ?? 0);
+    const crossed = bands.filter((band) => sample.remaining * 100 <= sample.limit * band.remainingPercent);
+    const newCrossed = crossed.filter((band) => !warned.has(band.remainingPercent));
+    for (const band of crossed)
+        warned.add(band.remainingPercent);
+    const active = newCrossed.at(-1);
+    const state = {
+        resource: sample.resource,
+        limit: sample.limit,
+        ...(sample.used !== undefined && { lastUsed: sample.used }),
+        lastRemaining: sample.remaining,
+        resetAt: sample.resetAt,
+        warnedThresholds: bands
+            .map((band) => band.remainingPercent)
+            .filter((threshold) => warned.has(threshold)),
+        rearmEpoch,
+    };
+    if (active === undefined)
+        return { state };
+    return {
+        warning: {
+            resource: "graphql",
+            thresholdPercent: active.remainingPercent,
+            remaining: sample.remaining,
+            limit: sample.limit,
+            ...(sample.used !== undefined && { used: sample.used }),
+            resetAt: sample.resetAt,
+            pollIntervalMinutes: active.pollIntervalMinutes,
+            pollTimeoutMinutes: active.pollIntervalMinutes * 2,
+        },
+        state,
+    };
+}

package/bin/state/graphql-quota-warnings.d.mts

@@ -0,0 +1,6 @@
+import type { GraphqlQuotaWarningBand } from "../config/load.mts";
+import type { GraphqlQuotaWarning, GraphqlApiUsage } from "../types.mts";
+export declare function evaluateWorktreeGraphqlQuotaWarning(key: {
+    owner: string;
+    repo: string;
+}, bands: GraphqlQuotaWarningBand[], sample: GraphqlApiUsage, persist: boolean, now?: number): Promise<GraphqlQuotaWarning | undefined>;

package/bin/state/graphql-quota-warnings.mjs

@@ -0,0 +1,105 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { resolveStateBase } from "./base.mjs";
+import { SAFE_SEGMENT } from "../util/path-segment.mjs";
+import { getWorktreeKey } from "../util/worktree.mjs";
+import { claimWarning } from "./graphql-quota-claims.mjs";
+import { evaluateGraphqlQuotaWarning, } from "./graphql-quota-policy.mjs";
+const pendingStateUpdates = new Map();
+const sessionStates = new Map();
+export async function evaluateWorktreeGraphqlQuotaWarning(key, bands, sample, persist, now = Date.now() / 1000) {
+    if (bands.length === 0)
+        return undefined;
+    const path = await warningStatePath(key);
+    if (path === undefined) {
+        const sessionKey = `${key.owner}/${key.repo}`;
+        if (!persist) {
+            return evaluateGraphqlQuotaWarning(bands, sample, sessionStates.get(sessionKey) ?? null, now)
+                .warning;
+        }
+        return serializeStateUpdate(`session:${sessionKey}`, async () => {
+            const evaluated = evaluateGraphqlQuotaWarning(bands, sample, sessionStates.get(sessionKey) ?? null, now);
+            sessionStates.set(sessionKey, evaluated.state);
+            return evaluated.warning;
+        });
+    }
+    if (!persist) {
+        const previous = await readState(path);
+        return evaluateGraphqlQuotaWarning(bands, sample, previous, now).warning;
+    }
+    return serializeStateUpdate(path, async () => {
+        const previous = await readState(path);
+        const evaluated = evaluateGraphqlQuotaWarning(bands, sample, previous, now);
+        const warning = evaluated.warning !== undefined &&
+            (await claimWarning(path, evaluated.warning, now, evaluated.state.rearmEpoch))
+            ? evaluated.warning
+            : undefined;
+        await writeState(path, evaluated.state);
+        return warning;
+    });
+}
+async function serializeStateUpdate(key, update) {
+    const previous = pendingStateUpdates.get(key) ?? Promise.resolve();
+    const result = previous.then(update);
+    const completion = result.then(() => undefined, () => undefined);
+    pendingStateUpdates.set(key, completion);
+    void completion.finally(() => {
+        if (pendingStateUpdates.get(key) === completion) {
+            pendingStateUpdates.delete(key);
+        }
+    });
+    return result;
+}
+async function warningStatePath(key) {
+    if (!SAFE_SEGMENT.test(key.owner) || !SAFE_SEGMENT.test(key.repo)) {
+        throw new Error(`Invalid repo key segments: ${key.owner}/${key.repo}`);
+    }
+    let worktreeKey;
+    try {
+        worktreeKey = await getWorktreeKey();
+    }
+    catch {
+        return undefined;
+    }
+    return join(resolveStateBase(), `${key.owner}-${key.repo}`, "worktrees", `${worktreeKey}-graphql-quota-warnings.json`);
+}
+async function readState(path) {
+    try {
+        const parsed = JSON.parse(await readFile(path, "utf8"));
+        if (typeof parsed.resource !== "string" ||
+            !Number.isFinite(parsed.limit) ||
+            !Number.isFinite(parsed.lastRemaining) ||
+            !Number.isFinite(parsed.resetAt) ||
+            !Array.isArray(parsed.warnedThresholds)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+async function writeState(path, state) {
+    let tmp;
+    try {
+        await mkdir(dirname(path), { recursive: true });
+        tmp = `${path}.${randomUUID()}.tmp`;
+        await writeFile(tmp, JSON.stringify(state), "utf8");
+        await rename(tmp, path);
+        tmp = undefined;
+    }
+    catch {
+        // Best-effort warning state must never fail the command.
+    }
+    finally {
+        if (tmp !== undefined) {
+            try {
+                await unlink(tmp);
+            }
+            catch {
+                // Best-effort cleanup.
+            }
+        }
+    }
+}

package/bin/state/rest-cache.d.mts

@@ -0,0 +1,48 @@
+/**
+ * Cross-tick GitHub API response cache — reduces redundant requests across
+ * `pr-shepherd` poll ticks.
+ *
+ * Two entry kinds, both keyed by a caller-chosen logical `name` (hashed to a
+ * filesystem-safe filename, mirroring seen-comments.mts):
+ *
+ * - "etag" entries back conditional REST requests (`If-None-Match`). A 200
+ *   response overwrites the entry; a 304 leaves it untouched. Used for list
+ *   endpoints whose content can change from tick to tick (job lists, run
+ *   lists).
+ * - "derived" entries cache a value computed from a response that is
+ *   immutable once identified by its key — job-log excerpts once a job is
+ *   terminal, check-run annotations once the check is COMPLETED. No ETag
+ *   applies; the cache is keyed on an immutable identity instead.
+ *
+ * Entries live under `$PR_SHEPHERD_STATE_DIR/<owner>-<repo>/<pr>/rest-cache/`
+ * and are removed for free when `pr-shepherd clean` deletes the PR's state
+ * directory — there is no separate pruning routine.
+ */
+export interface StateKey {
+    owner: string;
+    repo: string;
+    pr: number;
+}
+export interface EtagCacheEntry {
+    kind: "etag";
+    name: string;
+    etag: string;
+    body: unknown;
+    storedAt: number;
+    headSha?: string;
+}
+export interface DerivedCacheEntry<T = unknown> {
+    kind: "derived";
+    name: string;
+    value: T;
+    storedAt: number;
+    headSha?: string;
+}
+export declare function loadEtagEntry(key: StateKey, name: string): Promise<EtagCacheEntry | null>;
+export declare function storeEtagEntry(key: StateKey, name: string, fields: {
+    etag: string;
+    body: unknown;
+    headSha?: string;
+}): Promise<void>;
+export declare function loadDerived<T = unknown>(key: StateKey, name: string): Promise<DerivedCacheEntry<T> | null>;
+export declare function storeDerived<T = unknown>(key: StateKey, name: string, value: T, headSha?: string): Promise<void>;

package/bin/state/rest-cache.mjs

@@ -0,0 +1,91 @@
+/**
+ * Cross-tick GitHub API response cache — reduces redundant requests across
+ * `pr-shepherd` poll ticks.
+ *
+ * Two entry kinds, both keyed by a caller-chosen logical `name` (hashed to a
+ * filesystem-safe filename, mirroring seen-comments.mts):
+ *
+ * - "etag" entries back conditional REST requests (`If-None-Match`). A 200
+ *   response overwrites the entry; a 304 leaves it untouched. Used for list
+ *   endpoints whose content can change from tick to tick (job lists, run
+ *   lists).
+ * - "derived" entries cache a value computed from a response that is
+ *   immutable once identified by its key — job-log excerpts once a job is
+ *   terminal, check-run annotations once the check is COMPLETED. No ETag
+ *   applies; the cache is keyed on an immutable identity instead.
+ *
+ * Entries live under `$PR_SHEPHERD_STATE_DIR/<owner>-<repo>/<pr>/rest-cache/`
+ * and are removed for free when `pr-shepherd clean` deletes the PR's state
+ * directory — there is no separate pruning routine.
+ */
+import { readFile, writeFile, rename, unlink, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { resolvePrStatePath } from "./base.mjs";
+export async function loadEtagEntry(key, name) {
+    const entry = await readEntry(key, name);
+    return entry?.kind === "etag" ? entry : null;
+}
+export async function storeEtagEntry(key, name, fields) {
+    await writeEntry(key, name, {
+        kind: "etag",
+        name,
+        etag: fields.etag,
+        body: fields.body,
+        storedAt: Date.now(),
+        ...(fields.headSha !== undefined && { headSha: fields.headSha }),
+    });
+}
+export async function loadDerived(key, name) {
+    const entry = await readEntry(key, name);
+    return entry?.kind === "derived" ? entry : null;
+}
+export async function storeDerived(key, name, value, headSha) {
+    await writeEntry(key, name, {
+        kind: "derived",
+        name,
+        value,
+        storedAt: Date.now(),
+        ...(headSha !== undefined && { headSha }),
+    });
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+async function readEntry(key, name) {
+    try {
+        const raw = await readFile(resolvePath(key, name), "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+async function writeEntry(key, name, entry) {
+    let tmp;
+    try {
+        const path = resolvePath(key, name);
+        await mkdir(dirname(path), { recursive: true });
+        tmp = `${path}.${randomUUID()}.tmp`;
+        await writeFile(tmp, JSON.stringify(entry), "utf8");
+        await rename(tmp, path);
+        tmp = undefined;
+    }
+    catch {
+        // best-effort — a failed cache write just means the next tick re-fetches
+    }
+    finally {
+        if (tmp !== undefined) {
+            try {
+                await unlink(tmp);
+            }
+            catch {
+                // best-effort cleanup
+            }
+        }
+    }
+}
+function resolvePath(key, name) {
+    const hash = createHash("sha256").update(name, "utf8").digest("hex");
+    return resolvePrStatePath(key, "rest-cache", `${hash}.json`);
+}

package/bin/types/api-usage.d.mts

@@ -0,0 +1,31 @@
+export interface ApiResourceUsage {
+    resource: string;
+    requestCount: number;
+    limit: number;
+    used?: number;
+    remaining: number;
+    resetAt: number;
+}
+export interface GraphqlApiUsage extends ApiResourceUsage {
+    /** Exact sum reported by rateLimit.cost for GraphQL queries in this command. */
+    measuredQueryCost: number;
+    /** Requests without an exact cost, principally GraphQL mutations. */
+    unmeasuredRequestCount: number;
+    /** Exact sum reported by rateLimit.nodeCount for measured GraphQL queries. */
+    nodeCount: number;
+}
+export interface ApiUsage {
+    credentialSources: string[];
+    graphql?: GraphqlApiUsage;
+    rest?: ApiResourceUsage[];
+}
+export interface GraphqlQuotaWarning {
+    resource: "graphql";
+    thresholdPercent: number;
+    remaining: number;
+    limit: number;
+    used?: number;
+    resetAt: number;
+    pollIntervalMinutes: number;
+    pollTimeoutMinutes: number;
+}

package/bin/types/api-usage.mjs

@@ -0,0 +1 @@
+export {};

package/bin/types/iterate.d.mts

@@ -5,6 +5,7 @@ import type { MergeRequirements } from "./merge-requirements.mts";
 import type { EscalateDetails } from "./escalate.mts";
 import type { MergeCommandPlan } from "./merge-action.mts";
 import type { ProtectedRun } from "./protected-run.mts";
+import type { ApiUsage, GraphqlQuotaWarning } from "./api-usage.mts";
 export type ShepherdAction = "wait" | "fix_code" | "mark_ready" | "merge" | "cancel" | "escalate";
 export interface IterateResultSummary {
     passing: number;
@@ -41,6 +42,8 @@ export interface IterateResultBase {
     supersededNames?: string[];
     activity?: PrActivitySummary;
     mergeQueue?: import("./merge-queue.mts").MergeQueueReport;
+    apiUsage?: ApiUsage;
+    quotaWarning?: GraphqlQuotaWarning;
 }
 interface IterateResultWait extends IterateResultBase {
     action: "wait";
@@ -129,12 +132,12 @@ export interface IterateCommandOptions extends GlobalOptions {
     noAutoMarkReady?: boolean;
     /** Legacy no-op retained for API compatibility; workflow runs are never cancelled. */
     noAutoCancelActionable?: boolean;
-    /** Override stall timeout seconds. Defaults to config.iterate.stallTimeoutMinutes * 60. */
     stallTimeoutSeconds?: number;
     /** Legacy per-invocation no-op retained for API compatibility. */
     neverCancelRuns?: string[];
     persistSeen?: boolean;
     /** Shepherd through readiness and emit the exact merge/queue command when ready. */
     merge?: boolean;
+    deferQuotaWarning?: boolean;
 }
 export {};

package/bin/types/report.d.mts

@@ -136,6 +136,8 @@ export interface AgentCheck {
     /** One-line status text shown in the GitHub UI (e.g. "67.68% of diff hit (target 85.00%)"). */
     summary?: string;
     logExcerpt?: string;
+    /** `gh run rerun` command, present only when the check has a runId and the viewer's repository role grants Actions rerun capability (WRITE+). */
+    rerunCommand?: string;
     annotations?: CheckAnnotation[];
     annotationOnly?: true;
     scope?: "merge_group";

package/bin/types.d.mts

@@ -12,3 +12,4 @@ export * from "./types/merge-requirements.mts";
 export * from "./types/merge-action.mts";
 export * from "./types/escalate.mts";
 export * from "./types/merge-queue.mts";
+export * from "./types/api-usage.mts";

package/bin/types.mjs

@@ -12,3 +12,4 @@ export * from "./types/merge-requirements.mjs";
 export * from "./types/merge-action.mjs";
 export * from "./types/escalate.mjs";
 export * from "./types/merge-queue.mjs";
+export * from "./types/api-usage.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pr-shepherd",
-  "version": "0.44.0",
+  "version": "0.45.0",
   "description": "Autonomous PR CI monitor and review-comment resolver for agentic coding tools",
   "keywords": [
     "automation",

package/plugins/pr-shepherd/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "pr-shepherd",
-  "version": "0.44.0",
+  "version": "0.45.0",
   "description": "Autonomous PR CI monitor and review-comment resolver for Codex.",
   "author": {
     "name": "Jonathan Ong",

package/plugins/pr-shepherd/.codex.mcp.json

@@ -2,7 +2,7 @@
   "mcpServers": {
     "pr-shepherd": {
       "command": "npx",
-      "args": ["--yes", "--package", "pr-shepherd@0.44.0", "pr-shepherd-mcp"]
+      "args": ["--yes", "--package", "pr-shepherd@0.45.0", "pr-shepherd-mcp"]
     }
   }
 }

package/plugins/pr-shepherd/.mcp.json

@@ -1,6 +1,6 @@
 {
   "pr-shepherd": {
     "command": "npx",
-    "args": ["--yes", "--package", "pr-shepherd@0.44.0", "pr-shepherd-mcp"]
+    "args": ["--yes", "--package", "pr-shepherd@0.45.0", "pr-shepherd-mcp"]
   }
 }