co-maintainer 0.4.0-beta.1

package/dist/src/services/jobs.js

@@ -0,0 +1,222 @@
+import { readConfig } from "../config.js";
+import { claimJob, getJob, getQueuedJobByKey, getRunningJobByKey, insertJob, listJobs, setJobStatus, } from "../store/jobs.js";
+import { appendLog as storeAppendLog, listLogs } from "../store/job_logs.js";
+import { redact } from "../util/redact.js";
+import { abortQueuedRemoteReviewRow } from "./remote_review_abort.js";
+import { getReviewByJobId } from "../store/reviews.js";
+const handlers = new Map();
+export function registerHandler(type, handler) {
+    handlers.set(type, handler);
+}
+const subscribers = new Map();
+export function subscribeToLogs(jobId, fn) {
+    const set = subscribers.get(jobId) ?? new Set();
+    set.add(fn);
+    subscribers.set(jobId, set);
+    return () => set.delete(fn);
+}
+function log(jobId, level, message) {
+    const clean = redact(message);
+    const seq = storeAppendLog(jobId, level, clean);
+    const line = {
+        job_id: jobId,
+        seq,
+        at: new Date().toISOString(),
+        level,
+        message: clean,
+    };
+    for (const fn of subscribers.get(jobId) ?? [])
+        fn(line);
+}
+export function getLogsSince(jobId, fromSeq = 0) {
+    return listLogs(jobId, fromSeq);
+}
+export function enqueue(input) {
+    const queueKey = input.queueKey ??
+        (input.type === "review" && input.prNumber !== undefined
+            ? `review:${input.repo}:${input.prNumber}`
+            : undefined);
+    if (queueKey) {
+        const existing = getQueuedJobByKey(queueKey);
+        if (existing) {
+            const age = Date.now() - Date.parse(existing.created_at);
+            if (input.debounceMs && age < input.debounceMs) {
+                return { id: existing.id, debounced: true };
+            }
+            const id = crypto.randomUUID();
+            setJobStatus(existing.id, "canceled", {
+                superseded_by: id,
+                cancel_reason: "superseded",
+            });
+            log(existing.id, "info", `superseded by ${id}`);
+            insertJob({ ...input, id, queueKey });
+            return { id, debounced: false };
+        }
+    }
+    const id = crypto.randomUUID();
+    insertJob({ ...input, id, queueKey });
+    return { id, debounced: false };
+}
+const running = new Map();
+const pendingCancelReason = new Map();
+async function runJob(job) {
+    const handler = handlers.get(job.type);
+    const logFn = (level, message) => log(job.id, level, message);
+    if (!handler) {
+        setJobStatus(job.id, "failed", {
+            error: `no handler registered for job type ${job.type}`,
+        });
+        return;
+    }
+    const controller = new AbortController();
+    running.set(job.id, controller);
+    try {
+        await handler.run(job, logFn, controller.signal);
+        const status = controller.signal.aborted ? "canceled" : "done";
+        const cancelReason = pendingCancelReason.get(job.id);
+        setJobStatus(job.id, status, cancelReason ? { cancel_reason: cancelReason } : {});
+        log(job.id, "status", status);
+    }
+    catch (error) {
+        const status = controller.signal.aborted ? "canceled" : "failed";
+        const message = error instanceof Error ? error.message : String(error);
+        const cancelReason = pendingCancelReason.get(job.id);
+        setJobStatus(job.id, status, controller.signal.aborted
+            ? cancelReason
+                ? { cancel_reason: cancelReason }
+                : {}
+            : { error: String(error) });
+        if (status === "failed")
+            log(job.id, "error", message);
+        log(job.id, "status", status);
+    }
+    finally {
+        running.delete(job.id);
+        pendingCancelReason.delete(job.id);
+    }
+}
+function runningRemoteReviewsPerToken() {
+    const counts = new Map();
+    for (const job of listJobs({ status: "running" })) {
+        if (job.type !== "remote_review")
+            continue;
+        const review = getReviewByJobId(job.id);
+        if (!review?.token_id)
+            continue;
+        counts.set(review.token_id, (counts.get(review.token_id) ?? 0) + 1);
+    }
+    return counts;
+}
+function claimNextEligible() {
+    const config = readConfig();
+    const perTokenLimit = config.maxConcurrentRemoteReviewsPerToken;
+    const remoteRunning = perTokenLimit
+        ? runningRemoteReviewsPerToken()
+        : undefined;
+    const oldestFirst = listJobs({ status: "queued" }).slice().reverse();
+    for (const candidate of oldestFirst) {
+        if (!handlers.has(candidate.type))
+            continue;
+        if (candidate.queue_key) {
+            const busy = getRunningJobByKey(candidate.queue_key);
+            if (busy)
+                continue;
+        }
+        if (perTokenLimit && candidate.type === "remote_review") {
+            const review = getReviewByJobId(candidate.id);
+            const tokenId = review?.token_id;
+            if (tokenId && (remoteRunning.get(tokenId) ?? 0) >= perTokenLimit) {
+                continue;
+            }
+        }
+        if (!claimJob(candidate.id))
+            continue;
+        if (perTokenLimit && candidate.type === "remote_review") {
+            const review = getReviewByJobId(candidate.id);
+            if (review?.token_id) {
+                remoteRunning.set(review.token_id, (remoteRunning.get(review.token_id) ?? 0) + 1);
+            }
+        }
+        return getJob(candidate.id);
+    }
+    return undefined;
+}
+export async function claimAndRun() {
+    const limit = readConfig().maxConcurrentJobs;
+    if (limit && inFlight.size >= limit)
+        return false;
+    const job = claimNextEligible();
+    if (!job)
+        return false;
+    const run = runJob(job).finally(() => inFlight.delete(run));
+    inFlight.add(run);
+    await run;
+    return true;
+}
+const inFlight = new Set();
+let workerTimer;
+function tick() {
+    const limit = readConfig().maxConcurrentJobs;
+    while (!limit || inFlight.size < limit) {
+        const job = claimNextEligible();
+        if (!job)
+            break;
+        const p = runJob(job).finally(() => {
+            inFlight.delete(p);
+        });
+        inFlight.add(p);
+    }
+}
+export function startWorkerLoop(intervalMs = 1000) {
+    if (workerTimer !== undefined)
+        return;
+    workerTimer = setInterval(() => tick(), intervalMs);
+    tick();
+}
+export async function stopWorkerLoop() {
+    if (workerTimer !== undefined) {
+        clearInterval(workerTimer);
+        workerTimer = undefined;
+    }
+    await Promise.allSettled([...inFlight]);
+}
+/** Cooperative: aborts a running job's `AbortSignal` if this process is
+ * running it, or cancels it outright if it is merely queued. Returns false
+ * if neither applies (already finished, or running in another process). */
+export function cancel(jobId, reason = "dashboard_canceled") {
+    const controller = running.get(jobId);
+    if (controller) {
+        pendingCancelReason.set(jobId, reason);
+        controller.abort();
+        return true;
+    }
+    const job = getJob(jobId);
+    if (job?.status === "queued") {
+        abortQueuedRemoteReviewRow(jobId);
+        setJobStatus(jobId, "canceled", { cancel_reason: reason });
+        return true;
+    }
+    return false;
+}
+export async function recoverOrphans() {
+    const orphans = listJobs({ status: "running" });
+    for (const job of orphans) {
+        const handler = handlers.get(job.type);
+        const logFn = (level, message) => log(job.id, level, message);
+        if (handler?.reconcile) {
+            logFn("info", "recovering after a restart: reconciling instead of rerunning");
+            try {
+                const outcome = await handler.reconcile(job, logFn);
+                setJobStatus(job.id, outcome === "canceled" ? "canceled" : "done", outcome === "canceled" ? { cancel_reason: "server_restarted" } : {});
+            }
+            catch (error) {
+                setJobStatus(job.id, "failed", { error: String(error) });
+            }
+        }
+        else {
+            logFn("info", "recovering after a restart: requeued from the top");
+            setJobStatus(job.id, "queued");
+        }
+    }
+    return orphans.length;
+}

package/dist/src/services/remote_review.d.ts

@@ -0,0 +1,10 @@
+import type { RemoteTokenRow } from "../store/rows.ts";
+export declare function submitRemoteReview(token: RemoteTokenRow, body: Record<string, unknown>): {
+    jobId: string;
+    reviewId: string;
+} | {
+    error: string;
+    status: number;
+    code: string;
+};
+export declare function registerRemoteReviewHandler(): void;

package/dist/src/services/remote_review.js

@@ -0,0 +1,274 @@
+import { VERSION } from "../version.js";
+import { resolvedFromFirstReview, revisionStats, sortResolvedFindings, summaryCounts, toJsonFinding, } from "../cli/review_result.js";
+import { parseFindings } from "../pr/findings.js";
+import { codegraphToolHandlersForBridge } from "../pr/codegraph_tools.js";
+import { reviewWorkspaceRevision } from "../pr/reviewer.js";
+import { buildCarryPromptSection, classifyCarryItems, incrementalDiffPaths, } from "../review/carry_over.js";
+import { remoteBridgeToolHandlers } from "../remote/tool_bridge.js";
+import { revisionFromSubmitJson } from "../remote/revision_from_submit.js";
+import { closeRemoteSession, openRemoteSession, setRemoteSyncResult, } from "../remote/server/sessions.js";
+import { readConfig } from "../config.js";
+import { withLogSink } from "../util/log.js";
+import { cancel, registerHandler } from "./jobs.js";
+import { recordAiCost } from "./setup.js";
+import { findRepoByFullName } from "../store/repos.js";
+import { deleteRemoteReviewInput, findRemoteReviewInputByRequest, getRemoteReviewInput, insertRemoteReviewInput, } from "../store/remote_review_inputs.js";
+import { insertFinding, listCarryableFindingsForReview, } from "../store/findings.js";
+import { deleteSubjectRevision, getOrCreateRemoteSubject, getSubjectRevision, parseRevisionFiles, parseVisiblePaths, saveSubjectRevision, } from "../store/subjects.js";
+import { getReviewByJobId, insertRemoteReview, setReviewStatus, } from "../store/reviews.js";
+import { insertJob, listJobsByQueueKey, setJobStatus } from "../store/jobs.js";
+const REPO_UNAVAILABLE = "Sorry, we could not access this repository.";
+function remoteQueueKey(repo, branch, tokenId) {
+    return `remote:${repo}:${branch}:${tokenId}`;
+}
+function reviewOptionsForRepo(repo, useCodegraph) {
+    const config = readConfig();
+    return {
+        command: "review",
+        repo,
+        debug: false,
+        logTime: false,
+        useCodegraph,
+        improveMatrix: 1,
+        ghConcurrent: 1,
+        aiConcurrent: 3,
+        auth: config.auth ?? "gh",
+        githubPat: config.githubPat,
+        ai: config.ai ?? "openrouter",
+        aiToken: config.token,
+        lowModel: config.lowModel,
+        highModel: config.highModel,
+        synthesisVersion: 16,
+        includeCodebase: true,
+        includePullRequests: true,
+        includePullRequestChanges: true,
+        includeCommitHistory: true,
+        includeHowRepoWorks: true,
+    };
+}
+function supersedeActiveRemoteJobs(queueKey, supersededBy) {
+    for (const job of listJobsByQueueKey(queueKey, ["queued", "running"])) {
+        if (job.id === supersededBy)
+            continue;
+        if (job.status === "running") {
+            cancel(job.id, "superseded");
+        }
+        else {
+            setJobStatus(job.id, "canceled", {
+                superseded_by: supersededBy,
+                cancel_reason: "superseded",
+            });
+        }
+    }
+}
+export function submitRemoteReview(token, body) {
+    const requestId = String(body.requestId);
+    const existing = findRemoteReviewInputByRequest(token.id, requestId);
+    if (existing) {
+        const review = getReviewByJobId(existing.job_id);
+        if (review) {
+            return { jobId: existing.job_id, reviewId: review.id };
+        }
+    }
+    const repoRow = findRepoByFullName(String(body.repo));
+    if (!repoRow || repoRow.active !== 1) {
+        return { error: REPO_UNAVAILABLE, status: 404, code: "repo_unavailable" };
+    }
+    if (typeof body.branch !== "string") {
+        return {
+            error: "branch must be a string",
+            status: 400,
+            code: "bad_request",
+        };
+    }
+    const branch = body.branch;
+    const fresh = body.fresh === true;
+    const subject = getOrCreateRemoteSubject(repoRow.full_name, branch, token.id);
+    if (fresh)
+        deleteSubjectRevision(subject.id);
+    const jobId = crypto.randomUUID();
+    const reviewId = crypto.randomUUID();
+    const queueKey = remoteQueueKey(repoRow.full_name, branch, token.id);
+    supersedeActiveRemoteJobs(queueKey, jobId);
+    const revision = body.revision ?? {};
+    const capabilities = body.capabilities ?? { tools: [] };
+    insertRemoteReviewInput({
+        jobId,
+        revisionJson: JSON.stringify(revision),
+        capabilitiesJson: JSON.stringify(capabilities),
+        requestId,
+        tokenId: token.id,
+    });
+    const config = readConfig();
+    insertRemoteReview({
+        id: reviewId,
+        subjectId: subject.id,
+        repo: repoRow.full_name,
+        branch,
+        tokenId: token.id,
+        tokenName: token.name,
+        jobId,
+        scope: "remote",
+        model: config.highModel ?? "unknown",
+    });
+    insertJob({
+        id: jobId,
+        type: "remote_review",
+        repo: repoRow.full_name,
+        queueKey,
+        args: { subjectId: subject.id, requestId, reviewId },
+    });
+    openRemoteSession({
+        jobId,
+        reviewId,
+        tokenId: token.id,
+        subjectId: subject.id,
+    });
+    return { jobId, reviewId };
+}
+export function registerRemoteReviewHandler() {
+    registerHandler("remote_review", {
+        async run(job, log, signal) {
+            const args = JSON.parse(job.args);
+            const reviewId = args.reviewId;
+            const subjectId = args.subjectId;
+            if (!reviewId)
+                throw new Error("remote review missing reviewId");
+            const input = getRemoteReviewInput(job.id);
+            if (!input)
+                throw new Error("remote review input missing");
+            const review = getReviewByJobId(job.id);
+            if (!review)
+                throw new Error("remote review row missing");
+            setReviewStatus(reviewId, "running");
+            log("info", `remote review started for ${job.repo}`);
+            let completed = false;
+            try {
+                const revision = revisionFromSubmitJson(JSON.parse(input.revision_json));
+                const caps = JSON.parse(input.capabilities_json);
+                const allowed = new Set((caps.tools ?? [])
+                    .map((tool) => tool.name)
+                    .filter((name) => typeof name === "string" && name));
+                const useCodegraph = allowed.size > 0;
+                const options = reviewOptionsForRepo(job.repo, useCodegraph);
+                if (!options.aiToken || options.ai === "none") {
+                    throw new Error("server AI is not configured for remote review");
+                }
+                const extras = {};
+                if (subjectId) {
+                    const subjectRevision = getSubjectRevision(subjectId);
+                    if (subjectRevision) {
+                        const prevFiles = parseRevisionFiles(subjectRevision);
+                        const { unchanged } = incrementalDiffPaths(revision, prevFiles);
+                        extras.unchangedPaths = unchanged;
+                        const storedRows = listCarryableFindingsForReview(subjectRevision.review_id);
+                        const carryPrevious = {
+                            files: prevFiles,
+                            visiblePaths: parseVisiblePaths(subjectRevision),
+                            findings: storedRows.map((row) => ({
+                                id: row.id,
+                                path: row.path,
+                                lineFrom: row.line_from,
+                                lineTo: row.line_to,
+                                title: row.title,
+                                bodyMd: row.body_md,
+                                anchorText: row.anchor_text,
+                                severity: row.severity,
+                                firstSeenReviewId: row.first_seen_review_id ?? subjectRevision.review_id,
+                            })),
+                            guideBuiltAt: subjectRevision.guide_built_at,
+                        };
+                        const carryItems = classifyCarryItems(carryPrevious, revision, carryPrevious.visiblePaths, null);
+                        extras.carryPrompt = buildCarryPromptSection(carryItems, revision);
+                    }
+                }
+                if (useCodegraph) {
+                    const schemas = codegraphToolHandlersForBridge();
+                    extras.prepareCodegraphTools = async () => remoteBridgeToolHandlers(job.id, signal, allowed, schemas);
+                }
+                const started = performance.now();
+                let tokensIn = 0;
+                let tokensOut = 0;
+                let costUsd = 0;
+                let costKnown = true;
+                const result = await withLogSink((phase, message) => log("info", `[${phase}] ${message}`), () => reviewWorkspaceRevision(revision, options, "remote", async (response) => {
+                    tokensIn += response.tokensIn;
+                    tokensOut += response.tokensOut;
+                    if (response.cost === undefined)
+                        costKnown = false;
+                    else
+                        costUsd = (costUsd ?? 0) + response.cost;
+                    await recordAiCost(job.repo, "remote_review", response);
+                }, undefined, (message) => log("info", message), extras));
+                if (signal.aborted)
+                    return;
+                const parsed = parseFindings(result.text);
+                const filesByPath = new Map(revision.files.map((file) => [file.path, { patch: file.patch }]));
+                const findings = sortResolvedFindings(resolvedFromFirstReview(parsed, filesByPath));
+                const durationMs = Math.round(performance.now() - started);
+                setRemoteSyncResult(job.id, {
+                    subject: {
+                        repo: job.repo,
+                        branch: review.branch,
+                        prNumber: null,
+                    },
+                    revision: revisionStats(revision),
+                    guide: { builtAt: result.guideBuiltAt },
+                    summary: summaryCounts(findings),
+                    findings: findings.map(toJsonFinding),
+                    usage: {
+                        tokensIn,
+                        tokensOut,
+                        costUsd: costKnown ? costUsd : null,
+                    },
+                    remote: { jobId: job.id, reviewId, clientVersion: VERSION },
+                });
+                setReviewStatus(reviewId, "done", {
+                    findings_count: findings.length,
+                    guide_built_at: result.guideBuiltAt,
+                    duration_ms: durationMs,
+                    tokens_in: tokensIn,
+                    tokens_out: tokensOut,
+                    cost: costKnown ? costUsd : null,
+                });
+                if (subjectId) {
+                    saveSubjectRevision({
+                        subjectId,
+                        reviewId,
+                        files: revision.files,
+                        visiblePaths: [...result.visiblePaths],
+                        guideBuiltAt: result.guideBuiltAt,
+                    });
+                    for (const row of findings) {
+                        insertFinding({
+                            id: row.id,
+                            reviewId,
+                            severity: row.severity,
+                            path: row.path ?? undefined,
+                            lineFrom: row.lineFrom ?? undefined,
+                            lineTo: row.lineTo ?? undefined,
+                            title: row.title,
+                            bodyMd: row.bodyMd,
+                            anchorText: row.anchorText,
+                            state: row.state,
+                            closeReason: row.closeReason ?? null,
+                        });
+                    }
+                }
+                deleteRemoteReviewInput(job.id);
+                closeRemoteSession(job.id);
+                completed = true;
+                log("info", `remote review finished (${findings.length} findings)`);
+            }
+            finally {
+                if (!completed) {
+                    if (signal.aborted) {
+                        setReviewStatus(reviewId, "aborted");
+                    }
+                    deleteRemoteReviewInput(job.id);
+                    closeRemoteSession(job.id);
+                }
+            }
+        },
+    });
+}

package/dist/src/services/remote_review_abort.d.ts

@@ -0,0 +1,3 @@
+/** Queued remote reviews never enter the handler; sync the review row when the
+ * job is canceled from the dashboard or token deactivation. */
+export declare function abortQueuedRemoteReviewRow(jobId: string): void;

package/dist/src/services/remote_review_abort.js

@@ -0,0 +1,11 @@
+import { getReviewByJobId, setReviewStatus } from "../store/reviews.js";
+/** Queued remote reviews never enter the handler; sync the review row when the
+ * job is canceled from the dashboard or token deactivation. */
+export function abortQueuedRemoteReviewRow(jobId) {
+    const review = getReviewByJobId(jobId);
+    if (!review || review.kind !== "remote")
+        return;
+    if (review.status !== "queued")
+        return;
+    setReviewStatus(review.id, "aborted");
+}

package/dist/src/services/remote_token_jobs.d.ts

@@ -0,0 +1 @@
+export declare function cancelRemoteJobsForToken(tokenId: string, reason: "token_deactivated" | "token_deleted"): void;

package/dist/src/services/remote_token_jobs.js

@@ -0,0 +1,20 @@
+import { cancel } from "./jobs.js";
+import { abortQueuedRemoteReviewRow } from "./remote_review_abort.js";
+import { listJobs, setJobStatus } from "../store/jobs.js";
+import { getReviewByJobId } from "../store/reviews.js";
+export function cancelRemoteJobsForToken(tokenId, reason) {
+    for (const job of listJobs()) {
+        if (job.type !== "remote_review")
+            continue;
+        const review = getReviewByJobId(job.id);
+        if (!review || review.token_id !== tokenId)
+            continue;
+        if (job.status === "queued") {
+            setJobStatus(job.id, "canceled", { cancel_reason: reason });
+            abortQueuedRemoteReviewRow(job.id);
+        }
+        else if (job.status === "running") {
+            cancel(job.id, reason);
+        }
+    }
+}

package/dist/src/services/remote_tokens.d.ts

@@ -0,0 +1,13 @@
+import { deleteRemoteToken, listRemoteTokens, setRemoteTokenActive, touchRemoteToken } from "../store/remote_tokens.ts";
+import type { RemoteTokenRow } from "../store/rows.ts";
+export declare function generateRemoteBearerToken(): string;
+export declare function hashRemoteBearerToken(token: string): Promise<string>;
+export declare function validateRemoteTokenName(name: string): string | null;
+export declare function createRemoteToken(name: string): Promise<{
+    id: string;
+    name: string;
+    token: string;
+}>;
+export declare function resolveRemoteToken(bearer: string): Promise<RemoteTokenRow | undefined>;
+export declare function lookupRemoteBearer(bearer: string): Promise<RemoteTokenRow | "invalid" | "inactive">;
+export { deleteRemoteToken, listRemoteTokens, setRemoteTokenActive, touchRemoteToken, };

package/dist/src/services/remote_tokens.js

@@ -0,0 +1,57 @@
+import { deleteRemoteToken, findRemoteTokenByHash, findRemoteTokenByName, insertRemoteToken, listRemoteTokens, setRemoteTokenActive, touchRemoteToken, } from "../store/remote_tokens.js";
+const NAME_RE = /^[\w][\w .-]{0,63}$/;
+async function sha256Hex(value) {
+    const bytes = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+    return [...new Uint8Array(bytes)]
+        .map((byte) => byte.toString(16).padStart(2, "0"))
+        .join("");
+}
+function base64Url(bytes) {
+    const bin = [...bytes].map((b) => String.fromCharCode(b)).join("");
+    return btoa(bin).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+export function generateRemoteBearerToken() {
+    const bytes = new Uint8Array(32);
+    crypto.getRandomValues(bytes);
+    return `cmr_${base64Url(bytes)}`;
+}
+export async function hashRemoteBearerToken(token) {
+    return sha256Hex(token);
+}
+export function validateRemoteTokenName(name) {
+    const trimmed = name.trim();
+    if (!NAME_RE.test(trimmed)) {
+        return "name must be 1–64 characters (letters, numbers, spaces, . -)";
+    }
+    return null;
+}
+export async function createRemoteToken(name) {
+    const err = validateRemoteTokenName(name);
+    if (err)
+        throw new Error(err);
+    const trimmed = name.trim();
+    if (findRemoteTokenByName(trimmed)) {
+        throw new Error("name_taken");
+    }
+    const id = crypto.randomUUID();
+    const token = generateRemoteBearerToken();
+    const tokenHash = await hashRemoteBearerToken(token);
+    insertRemoteToken(id, trimmed, tokenHash);
+    return { id, name: trimmed, token };
+}
+export async function resolveRemoteToken(bearer) {
+    const status = await lookupRemoteBearer(bearer);
+    return status === "invalid" || status === "inactive" ? undefined : status;
+}
+export async function lookupRemoteBearer(bearer) {
+    const token = bearer.startsWith("cmr_") ? bearer : `cmr_${bearer}`;
+    const hash = await hashRemoteBearerToken(token);
+    const row = findRemoteTokenByHash(hash);
+    if (!row)
+        return "invalid";
+    if (row.active !== 1)
+        return "inactive";
+    touchRemoteToken(row.id);
+    return row;
+}
+export { deleteRemoteToken, listRemoteTokens, setRemoteTokenActive, touchRemoteToken, };

package/dist/src/services/replies.d.ts

@@ -0,0 +1,7 @@
+import type { AiProvider, GitHubClient } from "../types.ts";
+import { type LogFn } from "./jobs.ts";
+import type { JobRow } from "../store/rows.ts";
+export declare function runReplyJob(job: JobRow, log: LogFn, client?: GitHubClient, ai?: AiProvider): Promise<void>;
+export declare function reconcileReply(job: JobRow, log: LogFn): Promise<void>;
+export declare function recoverReplyRequests(): number;
+export declare function registerReplyJobHandler(): void;