@event4u/agent-config 16.4.0 → 17.0.0

package/src/scripts/analysis_ledger.ts

@@ -0,0 +1,119 @@
+/**
+ * analysis_ledger.ts — the loop ledger of one analyst: seed plus three lens
+ * loops (Coverage, Adversary, Overbuild & sequencing), each appending a row
+ * whose every item carries an evidence object.
+ *
+ * Only `executed` and `read` evidence counts. A loop that changed no
+ * conclusion on such evidence is `no-external-signal`: it ran, it is recorded,
+ * and it does not count — re-reading one's own draft is not depth. All three
+ * lenses always run; loops 4–5 run only while the loop before added a
+ * top-tier item.
+ */
+
+export const LENSES = ['coverage', 'adversary', 'overbuild-sequencing'] as const;
+export type Lens = (typeof LENSES)[number];
+
+export const EVIDENCE_TIERS = ['executed', 'read', 'claimed', 'inferred'] as const;
+export type EvidenceTier = (typeof EVIDENCE_TIERS)[number];
+export const TOP_TIERS: readonly EvidenceTier[] = ['executed', 'read'];
+
+export const MANDATORY_LOOPS: number = LENSES.length;
+export const MAX_LOOPS = 5;
+
+export interface Evidence {
+    source_identity: string;
+    digest: string;
+    method: string;
+    claim: 'supported' | 'refuted';
+    tier: EvidenceTier;
+}
+
+/** `retained` is an item the lens tested and left standing — legal, but no changed conclusion. */
+export type ItemChange = 'added' | 'changed' | 'killed' | 'retained';
+
+export interface LedgerItem {
+    id: string;
+    change: ItemChange;
+    evidence: Evidence[];
+}
+
+export interface LoopRowInput {
+    lens: Lens;
+    items: LedgerItem[];
+}
+
+export interface LoopRow extends LoopRowInput {
+    loop: number;
+    status: 'counted' | 'no-external-signal';
+}
+
+export type NextLoop = { action: 'run'; loop: number; lens: Lens } | { action: 'stop'; reason: 'loop-cap' | 'plateau' };
+
+export class LedgerError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = 'LedgerError';
+    }
+}
+
+export function lensForLoop(loop: number): Lens {
+    return LENSES[(loop - 1) % LENSES.length] as Lens;
+}
+
+function isTopTier(evidence: Evidence): boolean {
+    return TOP_TIERS.includes(evidence.tier);
+}
+
+function changesConclusion(item: LedgerItem): boolean {
+    return item.change !== 'retained' && item.evidence.some(isTopTier);
+}
+
+export function addedTopTier(row: LoopRow): boolean {
+    return row.status === 'counted' && row.items.some((i) => i.change === 'added' && i.evidence.some(isTopTier));
+}
+
+export function assertLoopsSetting(loops: number): void {
+    if (!Number.isInteger(loops) || loops < MANDATORY_LOOPS || loops > MAX_LOOPS) {
+        throw new LedgerError(`--loops must be an integer from ${MANDATORY_LOOPS} to ${MAX_LOOPS}, got ${loops}`);
+    }
+}
+
+export function appendLoop(ledger: readonly LoopRow[], input: LoopRowInput): LoopRow[] {
+    const loop = ledger.length + 1;
+    if (loop > MAX_LOOPS) {
+        throw new LedgerError(`loop ${loop} exceeds the cap of ${MAX_LOOPS}`);
+    }
+    const expected = lensForLoop(loop);
+    if (input.lens !== expected) {
+        throw new LedgerError(`loop ${loop} must run the ${expected} lens, got ${input.lens}`);
+    }
+    for (const item of input.items) {
+        if (item.evidence.length === 0) {
+            throw new LedgerError(`loop ${loop}: item ${item.id} carries no evidence object`);
+        }
+        for (const ev of item.evidence) {
+            if (!EVIDENCE_TIERS.includes(ev.tier)) {
+                throw new LedgerError(`loop ${loop}: item ${item.id} has unknown tier ${String(ev.tier)}`);
+            }
+        }
+    }
+    const status = input.items.some(changesConclusion) ? 'counted' : 'no-external-signal';
+    return [...ledger, { loop, lens: input.lens, items: input.items, status }];
+}
+
+export function nextLoop(ledger: readonly LoopRow[], loops: number = MANDATORY_LOOPS): NextLoop {
+    assertLoopsSetting(loops);
+    const done = ledger.length;
+    if (done < MANDATORY_LOOPS) {
+        return { action: 'run', loop: done + 1, lens: lensForLoop(done + 1) };
+    }
+    if (done >= loops) return { action: 'stop', reason: 'loop-cap' };
+    const previous = ledger[done - 1] as LoopRow;
+    if (!addedTopTier(previous)) return { action: 'stop', reason: 'plateau' };
+    return { action: 'run', loop: done + 1, lens: lensForLoop(done + 1) };
+}
+
+export function ledgerSummary(ledger: readonly LoopRow[]): string {
+    const counted = ledger.filter((r) => r.status === 'counted').length;
+    return `Loops: ${ledger.length} run, ${counted} counted, ${ledger.length - counted} no-external-signal`;
+}

package/src/scripts/analysis_pr_optimize.ts

@@ -0,0 +1,219 @@
+/**
+ * analysis_pr_optimize.ts — `analyze:pr --optimize` (step 5.3, ADR-288 D6).
+ *
+ * Eligibility first: an open PR whose head branch lives in this repository and
+ * is writable gets fixes pushed to it; anything else gets a patch file beside
+ * the verdict. Each fix carries exactly one test disposition. Every push is a
+ * compare-and-swap on the head the run last saw — a moved head stops the run
+ * before it pushes. Re-review after each push; stop when nothing new clears
+ * the threshold or after three rounds.
+ *
+ * The port has no merge and no approve: the flow cannot do either.
+ */
+import { execFileSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+import { assertRefName, PublishError } from './analysis_publish.js';
+
+export const MAX_OPTIMIZE_ROUNDS = 3;
+
+/** Why a fix ships without a test; the disprove pass reviews each one. */
+export const INFEASIBLE_REASONS = ['no-test-harness', 'nondeterministic', 'external-dependency', 'docs-only', 'config-only'] as const;
+
+const OBJECT_ID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+
+export class OptimizeError extends Error {}
+
+export interface PrBranch {
+    pr: number;
+    state: 'OPEN' | 'CLOSED' | 'MERGED';
+    headRefName: string;
+    headSha: string;
+    isCrossRepository: boolean;
+    viewerCanPush: boolean;
+}
+
+export type Eligibility = { kind: 'push'; branch: string } | { kind: 'patch'; reason: string };
+
+export type Disposition =
+    | { kind: 'regression-test-red'; test: string }
+    | { kind: 'existing-test-red'; test: string }
+    | { kind: 'static-check'; check: string }
+    | { kind: 'infeasible'; reasonCode: string; reviewedBy: string };
+
+export interface Fix {
+    findingKey: string;
+    disposition: Disposition;
+}
+
+export interface KeyedFinding {
+    key: string;
+}
+
+export interface OptimizePort {
+    remoteHead(branch: string): string | null;
+    /** Applies and commits the fixes on top of `baseSha`, new files included; returns the new head. */
+    applyFixes(fixes: readonly Fix[], baseSha: string): string;
+    /** Fails, changing nothing, unless the remote head is exactly `expected`. */
+    push(branch: string, expected: string): void;
+    /** Writes the fixes, applied to `headSha`, as a patch file (new files included); returns its path. */
+    writePatch(pr: number, headSha: string, fixes: readonly Fix[]): string;
+}
+
+export type OptimizeEnd = 'converged' | 'round-cap' | 'moved-head' | 'patch' | 'fix-failed';
+
+export interface OptimizeResult {
+    end: OptimizeEnd;
+    rounds: number;
+    fixes: Fix[];
+    patch?: string;
+    reason?: string;
+    /** Findings a pushed fix was meant to remove that the re-review still reports. */
+    persisting?: string[];
+}
+
+export function eligibility(pr: PrBranch): Eligibility {
+    if (pr.state !== 'OPEN') return { kind: 'patch', reason: `PR #${pr.pr} is ${pr.state.toLowerCase()}` };
+    if (pr.isCrossRepository) return { kind: 'patch', reason: `PR #${pr.pr} comes from a fork` };
+    if (!pr.viewerCanPush) return { kind: 'patch', reason: `the head branch of PR #${pr.pr} is not writable` };
+    try {
+        return { kind: 'push', branch: assertRefName(pr.headRefName, 'head branch') };
+    } catch (err) {
+        if (err instanceof PublishError) return { kind: 'patch', reason: err.message };
+        throw err;
+    }
+}
+
+function nonEmpty(s: string): boolean {
+    return s.trim() !== '';
+}
+
+function checkDispositions(findings: readonly KeyedFinding[], fixes: readonly Fix[]): void {
+    const wanted = new Set(findings.map((f) => f.key));
+    const seen = new Set<string>();
+    for (const fix of fixes) {
+        if (!wanted.has(fix.findingKey)) throw new OptimizeError(`fix for ${fix.findingKey} answers no finding of this round`);
+        if (seen.has(fix.findingKey)) throw new OptimizeError(`finding ${fix.findingKey} carries more than one disposition`);
+        seen.add(fix.findingKey);
+        const d = fix.disposition;
+        const ok =
+            d.kind === 'infeasible'
+                ? (INFEASIBLE_REASONS as readonly string[]).includes(d.reasonCode) && nonEmpty(d.reviewedBy)
+                : nonEmpty(d.kind === 'static-check' ? d.check : d.test);
+        if (!ok) throw new OptimizeError(`finding ${fix.findingKey} has an incomplete ${d.kind} disposition`);
+    }
+    const missing = [...wanted].filter((k) => !seen.has(k));
+    if (missing.length > 0) throw new OptimizeError(`no disposition for: ${missing.join(', ')}`);
+}
+
+export function optimizePr(
+    pr: PrBranch,
+    port: OptimizePort,
+    review: (headSha: string) => KeyedFinding[],
+    planFixes: (findings: KeyedFinding[]) => Fix[],
+): OptimizeResult {
+    if (!OBJECT_ID.test(pr.headSha)) throw new OptimizeError(`head SHA ${JSON.stringify(pr.headSha)} is not a full object id`);
+    const target = eligibility(pr);
+    const done: Fix[] = [];
+    const known = new Set<string>();
+    let expected = pr.headSha;
+    for (let rounds = 0; ; rounds += 1) {
+        const found = review(expected);
+        const persisting = found.filter((f) => known.has(f.key)).map((f) => f.key);
+        if (persisting.length > 0) {
+            return { end: 'fix-failed', rounds, fixes: done, persisting, reason: `still reported after their fix: ${persisting.join(', ')}` };
+        }
+        const fresh = found;
+        if (fresh.length === 0) return { end: 'converged', rounds, fixes: done };
+        if (rounds >= MAX_OPTIMIZE_ROUNDS) return { end: 'round-cap', rounds, fixes: done };
+        const fixes = planFixes(fresh);
+        checkDispositions(fresh, fixes);
+        if (target.kind === 'patch') {
+            done.push(...fixes);
+            return { end: 'patch', rounds: rounds + 1, fixes: done, patch: port.writePatch(pr.pr, expected, fixes), reason: target.reason };
+        }
+        const remote = port.remoteHead(target.branch);
+        if (remote !== expected) {
+            return { end: 'moved-head', rounds, fixes: done, reason: `${target.branch} is at ${String(remote)}, expected ${expected}` };
+        }
+        const next = port.applyFixes(fixes, expected);
+        try {
+            port.push(target.branch, expected);
+        } catch (err) {
+            const why = err instanceof Error ? err.message : String(err);
+            return { end: 'moved-head', rounds, fixes: done, reason: `lease on ${target.branch} at ${expected} refused at push (${why}); local commit ${next} not pushed` };
+        }
+        for (const f of fresh) known.add(f.key);
+        done.push(...fixes);
+        expected = next;
+    }
+}
+
+/**
+ * The git port a door uses. Fixes are applied in a private detached worktree at
+ * the head the run pinned, never in the caller's checkout; every file the fix
+ * touches is staged, new files included. A push leases the expected head and
+ * fast-forwards only. `dispose` removes the worktree.
+ */
+export function gitOptimizePort(
+    repoCwd: string,
+    apply: (fixes: readonly Fix[], dir: string) => void,
+): OptimizePort & { dispose(): void } {
+    const run = (cwd: string, args: string[]): string => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: 'pipe' }).trim();
+    const sha = (s: string, what: string): string => {
+        if (!OBJECT_ID.test(s)) throw new OptimizeError(`${what} ${JSON.stringify(s)} is not a full object id`);
+        return s;
+    };
+    let dir: string | null = null;
+    const worktreeAt = (base: string): string => {
+        if (dir === null) {
+            dir = fs.mkdtempSync(path.join(os.tmpdir(), 'analyze-pr-fix-'));
+            run(repoCwd, ['worktree', 'add', '--detach', dir, sha(base, 'base SHA')]);
+        } else if (run(dir, ['rev-parse', 'HEAD']) !== base) {
+            throw new OptimizeError(`fix worktree is not at ${base}`);
+        }
+        return dir;
+    };
+    return {
+        remoteHead: (branch) => {
+            const ref = `refs/heads/${assertRefName(branch, 'branch')}`;
+            const row = run(repoCwd, ['ls-remote', 'origin', ref])
+                .split('\n')
+                .map((l) => l.split(/\s+/))
+                .find((cols) => cols[1] === ref);
+            return row?.[0] ?? null;
+        },
+        applyFixes: (fixes, baseSha) => {
+            const wt = worktreeAt(baseSha);
+            apply(fixes, wt);
+            run(wt, ['add', '--all']);
+            run(wt, ['commit', '-m', `fix: analyze:pr --optimize (${fixes.length} finding(s))`]);
+            return run(wt, ['rev-parse', 'HEAD']);
+        },
+        push: (branch, expected) => {
+            if (dir === null) throw new OptimizeError('nothing applied to push');
+            const ref = `refs/heads/${assertRefName(branch, 'branch')}`;
+            run(dir, ['merge-base', '--is-ancestor', sha(expected, 'expected head'), 'HEAD']);
+            run(dir, ['push', '--porcelain', `--force-with-lease=${ref}:${expected}`, 'origin', `HEAD:${ref}`]);
+        },
+        writePatch: (pr, headSha, fixes) => {
+            const wt = fs.mkdtempSync(path.join(os.tmpdir(), 'analyze-pr-patch-'));
+            run(repoCwd, ['worktree', 'add', '--detach', wt, sha(headSha, 'head SHA')]);
+            try {
+                apply(fixes, wt);
+                run(wt, ['add', '--all']);
+                const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'analyze-pr-')), `pr-${pr}.patch`);
+                fs.writeFileSync(file, `${run(wt, ['diff', '--cached', '--binary', '--no-color', '--no-ext-diff', 'HEAD'])}\n`);
+                return file;
+            } finally {
+                run(repoCwd, ['worktree', 'remove', '--force', wt]);
+            }
+        },
+        dispose: () => {
+            if (dir !== null) run(repoCwd, ['worktree', 'remove', '--force', dir]);
+            dir = null;
+        },
+    };
+}

package/src/scripts/analysis_pr_review.ts

@@ -0,0 +1,240 @@
+/**
+ * analysis_pr_review.ts — the read-only verdict of `analyze:pr` (step 5.2,
+ * ADR-288 D1, D9).
+ *
+ * The PR head is read in a throwaway worktree, the analysts and seats propose
+ * candidate findings, a model of a different family tries to disprove each,
+ * and what survives the confidence threshold is folded and classified against
+ * `base..head`. Every remote effect goes through a `PrReviewPort`; the only
+ * write it has is a comment, and it runs only on `--comment`.
+ *
+ * Finding a defect is model work and stays with the door; this module decides
+ * what of it is reported, so a clean head reports "no finding above threshold"
+ * instead of a padded list.
+ */
+import { execFileSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+export const DEFAULT_CONFIDENCE_THRESHOLD = 0.7;
+
+const OBJECT_ID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+
+export class ReviewError extends Error {}
+
+export type Severity = 'critical' | 'high' | 'medium' | 'low';
+
+export interface CandidateFinding {
+    severity: Severity;
+    file: string;
+    line: number;
+    claim: string;
+    evidence: string;
+    fix: string;
+    /** The proposer's own confidence, 0..1. */
+    confidence: number;
+    /** A command or input that shows the defect; null when there is none. */
+    reproduction: string | null;
+    /** A test that fails on the defect; null or absent when there is none. */
+    test?: string | null;
+    /** Model family of the analyst or seat that proposed it. */
+    family: string;
+}
+
+export interface DisproveResult {
+    refuted: boolean;
+    family: string;
+    note: string;
+}
+
+export interface PrFinding extends CandidateFinding {
+    origin: 'introduced' | 'pre-existing';
+    disprove_note: string;
+}
+
+export interface PrReviewPort {
+    /** A detached checkout of `headSha`; returns its path. */
+    openWorktree(headSha: string): string;
+    removeWorktree(worktree: string): void;
+    diff(baseSha: string, headSha: string): string;
+    comment(pr: number, body: string): void;
+}
+
+export interface PrReviewInput {
+    pr: number;
+    baseSha: string;
+    headSha: string;
+    comment: boolean;
+    threshold?: number;
+}
+
+export interface PrVerdict {
+    pr: number;
+    baseSha: string;
+    headSha: string;
+    findings: PrFinding[];
+    belowThreshold: number;
+    refuted: number;
+    duplicates: number;
+    /** ADR-288 D9 metric for this door: introduced findings that carry a reproduction or a test. */
+    metric: number;
+    text: string;
+}
+
+function assertObjectId(sha: string, what: string): string {
+    if (!OBJECT_ID.test(sha)) throw new ReviewError(`${what} ${JSON.stringify(sha)} is not a full object id`);
+    return sha;
+}
+
+function diffPath(raw: string): string | null {
+    let p = raw.trim();
+    if (p === '/dev/null') return null;
+    if (p.startsWith('"') && p.endsWith('"')) p = JSON.parse(p) as string;
+    return p.replace(/^b\//u, '');
+}
+
+/**
+ * Head-side line numbers added per file, read from a unified diff. Inside a
+ * hunk the header's line counts decide what is content, so an added line whose
+ * own text begins with `++ ` is never mistaken for a file header.
+ */
+export function addedLines(diff: string): Map<string, Set<number>> {
+    const out = new Map<string, Set<number>>();
+    let file: string | null = null;
+    let line = 0;
+    let oldLeft = 0;
+    let newLeft = 0;
+    for (const raw of diff.split('\n')) {
+        if (oldLeft > 0 || newLeft > 0) {
+            if (raw.startsWith('+')) {
+                if (file !== null) {
+                    let set = out.get(file);
+                    if (set === undefined) {
+                        set = new Set();
+                        out.set(file, set);
+                    }
+                    set.add(line);
+                }
+                line += 1;
+                newLeft -= 1;
+            } else if (raw.startsWith('-')) {
+                oldLeft -= 1;
+            } else if (raw.startsWith(' ') || raw === '') {
+                line += 1;
+                oldLeft -= 1;
+                newLeft -= 1;
+            }
+            continue;
+        }
+        if (raw.startsWith('+++ ')) {
+            file = diffPath(raw.slice(4));
+            continue;
+        }
+        const hunk = /^@@ -\d+(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/u.exec(raw);
+        if (hunk !== null) {
+            oldLeft = hunk[1] === undefined ? 1 : Number(hunk[1]);
+            line = Number(hunk[2]);
+            newLeft = hunk[3] === undefined ? 1 : Number(hunk[3]);
+        }
+    }
+    return out;
+}
+
+function dedupeKey(f: CandidateFinding): string {
+    return `${f.file}:${f.line}:${f.claim.trim().replace(/\s+/gu, ' ').toLowerCase()}`;
+}
+
+export function renderVerdict(v: Omit<PrVerdict, 'text'>, threshold: number): string {
+    const head = `analyze:pr #${v.pr} at ${v.headSha.slice(0, 12)} (base ${v.baseSha.slice(0, 12)})`;
+    const tally = `refuted ${v.refuted} · below threshold ${v.belowThreshold} · folded duplicates ${v.duplicates}`;
+    if (v.findings.length === 0) return `${head}\n\nno finding above threshold (${threshold}) — ${tally}\n`;
+    const rows = v.findings.map(
+        (f) =>
+            `- **${f.severity}** \`${f.file}:${f.line}\` — ${f.claim}\n` +
+            `  - evidence: ${f.evidence}\n` +
+            `  - fix: ${f.fix}\n` +
+            `  - confidence: ${f.confidence} · ${f.origin === 'introduced' ? 'introduced here' : 'pre-existing'}` +
+            (f.reproduction === null ? '' : `\n  - reproduction: ${f.reproduction}`) +
+            (f.test === null || f.test === undefined ? '' : `\n  - test: ${f.test}`),
+    );
+    return `${head}\n\n${rows.join('\n')}\n\n${tally}\n`;
+}
+
+/** Read-only by default: the port's `comment` runs only when `input.comment` is set. */
+export function reviewPr(
+    input: PrReviewInput,
+    port: PrReviewPort,
+    analyse: (worktree: string, diff: string) => CandidateFinding[],
+    disprove: (finding: CandidateFinding) => DisproveResult,
+): PrVerdict {
+    const baseSha = assertObjectId(input.baseSha, 'base SHA');
+    const headSha = assertObjectId(input.headSha, 'head SHA');
+    const threshold = input.threshold ?? DEFAULT_CONFIDENCE_THRESHOLD;
+    const worktree = port.openWorktree(headSha);
+    let candidates: CandidateFinding[];
+    let diff: string;
+    try {
+        diff = port.diff(baseSha, headSha);
+        candidates = analyse(worktree, diff);
+    } finally {
+        port.removeWorktree(worktree);
+    }
+    const added = addedLines(diff);
+    let belowThreshold = 0;
+    let refuted = 0;
+    let duplicates = 0;
+    const kept = new Map<string, PrFinding>();
+    for (const f of candidates) {
+        if (f.confidence < threshold) {
+            belowThreshold += 1;
+            continue;
+        }
+        const d = disprove(f);
+        if (d.family === f.family) {
+            throw new ReviewError(`disprove pass for ${f.file}:${f.line} ran on the proposer's own family (${f.family})`);
+        }
+        if (d.refuted) {
+            refuted += 1;
+            continue;
+        }
+        const key = dedupeKey(f);
+        const prior = kept.get(key);
+        if (prior !== undefined) {
+            duplicates += 1;
+            if (prior.confidence >= f.confidence) continue;
+        }
+        const origin = added.get(f.file)?.has(f.line) === true ? 'introduced' : 'pre-existing';
+        kept.set(key, { ...f, origin, disprove_note: d.note });
+    }
+    const findings = [...kept.values()];
+    const shown = (v: string | null | undefined): boolean => typeof v === 'string' && v.trim() !== '';
+    const metric = findings.filter((f) => f.origin === 'introduced' && (shown(f.reproduction) || shown(f.test))).length;
+    const base = { pr: input.pr, baseSha, headSha, findings, belowThreshold, refuted, duplicates, metric };
+    const text = renderVerdict(base, threshold);
+    if (input.comment) port.comment(input.pr, text);
+    return { ...base, text };
+}
+
+/** The git + gh port a door uses. Its one write is `gh pr comment`, reached only through `--comment`. */
+export function gitGhReviewPort(cwd: string): PrReviewPort {
+    const run = (bin: string, args: string[]): string => execFileSync(bin, args, { cwd, encoding: 'utf8', stdio: 'pipe' });
+    return {
+        openWorktree: (headSha) => {
+            const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'analyze-pr-'));
+            run('git', ['worktree', 'add', '--detach', dir, assertObjectId(headSha, 'head SHA')]);
+            return dir;
+        },
+        removeWorktree: (worktree) => {
+            run('git', ['worktree', 'remove', '--force', worktree]);
+        },
+        diff: (baseSha, headSha) =>
+            // Three dots: from the merge base, so commits the base gained later are never the PR's.
+            run('git', ['diff', '--no-color', '--no-ext-diff', `${assertObjectId(baseSha, 'base SHA')}...${assertObjectId(headSha, 'head SHA')}`]),
+        comment: (pr, body) => {
+            const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'analyze-pr-body-')), 'body.md');
+            fs.writeFileSync(file, body);
+            run('gh', ['pr', 'comment', String(pr), '--body-file', file]);
+        },
+    };
+}