@minionry/minion 0.7.36

package/dist/server/services/plan/review-gate.js

@@ -0,0 +1,409 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { persistTranscriptSession } from '../websocket/session-history.js';
+import { loadAgentPrompt } from './agent-loader.js';
+import { resolveIsCodeTask } from './issue-classification.js';
+import { appendCancellationNote, appendOutputHistoryEntry } from './issue-writer.js';
+import { resolveOutputPath } from './output-manager.js';
+import { createPlanRunner } from './plan-runner-factory.js';
+import { QUALITY_DELTA_MAX_FINDINGS, qualityDeltaDir } from './quality-delta.js';
+import { REVIEW_INCOMPLETE_CHECK } from './review-report.js';
+import { balancedObjectEnd, createVerdictStream, parseVerdictObject } from './review-verdict-stream.js';
+import { MAX_REVIEW_ATTEMPTS } from './types.js';
+export { MAX_REVIEW_ATTEMPTS };
+export const REVIEW_GATE_ENGINE = 'claude-code';
+export const REVIEW_GATE_MODEL = 'fable';
+export const REVIEW_GATE_EFFORT_LEVEL = 'max';
+export async function reviewIssue(options) {
+    const { workingDir, issue, pmDir, outputPath, onOutput, onPrompt, onComplete, logDir, boardDir, qualityDelta } = options;
+    const isCodeTask = resolveIsCodeTask(issue);
+    const issueType = isCodeTask ? 'code' : 'non-code';
+    try {
+        const prompt = buildReviewPrompt(issue, pmDir, outputPath, isCodeTask, boardDir, workingDir, qualityDelta);
+        onPrompt?.(prompt);
+        if (issue.reviewModel && issue.reviewModel !== REVIEW_GATE_MODEL) {
+            onOutput?.(`Review model '${issue.reviewModel}' overridden — the review gate is pinned to ${REVIEW_GATE_MODEL} at ${REVIEW_GATE_EFFORT_LEVEL} effort.\n`);
+        }
+        const stream = createVerdictStream(onOutput);
+        const runner = createPlanRunner('review', {
+            workingDir,
+            prompt,
+            engineId: REVIEW_GATE_ENGINE,
+            model: REVIEW_GATE_MODEL,
+            effortLevel: REVIEW_GATE_EFFORT_LEVEL,
+            verbose: true,
+            outputCallback: (text) => stream.write(text),
+            extraEnv: options.extraEnv,
+            abortSignal: options.abortSignal,
+            logLabel: 'pm-review',
+            logDir,
+        });
+        const result = await runner.run().finally(() => stream.flush());
+        await onComplete?.(result, prompt);
+        if (result.completed && result.assistantResponse) {
+            const verdict = applyQualityGate(await resolveVerdict(options, issueType, result.assistantResponse), qualityDelta);
+            const blocked = verdict.checks.find((c) => c.name === QUALITY_DELTA_CHECK && !c.passed);
+            if (blocked)
+                onOutput?.(`\nQuality gate (block): ${blocked.details}\n`);
+            return verdict;
+        }
+        return incompleteReviewResult(issue.id, issueType, options.abortSignal?.aborted ? 'Review aborted by user stop' : 'Review runner did not complete');
+    }
+    catch (err) {
+        return incompleteReviewResult(issue.id, issueType, options.abortSignal?.aborted
+            ? 'Review aborted by user stop'
+            : `Review threw an error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+async function resolveVerdict(options, issueType, reviewerOutput) {
+    const parsed = parseReviewOutput(options.issue.id, issueType, reviewerOutput);
+    if (!hasFailedChecksWithoutDetails(parsed))
+        return parsed;
+    options.onOutput?.('\nReview verdict listed failed checks without details — asking the reviewer for reasons.\n');
+    const followUp = await runDetailsFollowUp(options, issueType, parsed, reviewerOutput);
+    if (followUp && !hasFailedChecksWithoutDetails(followUp))
+        return followUp;
+    return incompleteReviewResult(options.issue.id, issueType, 'Reviewer reported failed checks without details');
+}
+export function getReviewAttemptCount(boardOrSandboxDir, issue) {
+    if (!boardOrSandboxDir)
+        return 0;
+    const reviewsDir = join(boardOrSandboxDir, 'reviews');
+    if (!existsSync(reviewsDir))
+        return 0;
+    try {
+        return readdirSync(reviewsDir).filter(f => f.startsWith(issue.id) && f.endsWith('.json')).length;
+    }
+    catch {
+        return 0;
+    }
+}
+export function persistReviewResult(boardOrSandboxDir, issue, result) {
+    if (!boardOrSandboxDir)
+        return;
+    const reviewsDir = join(boardOrSandboxDir, 'reviews');
+    if (!existsSync(reviewsDir))
+        mkdirSync(reviewsDir, { recursive: true });
+    try {
+        writeFileSync(join(reviewsDir, `${issue.id}-${Date.now()}.json`), JSON.stringify(result, null, 2), 'utf-8');
+    }
+    catch {   }
+}
+export function appendReviewFeedback(pmDir, issue, result) {
+    const fullPath = join(pmDir, issue.path);
+    try {
+        let content = readFileSync(fullPath, 'utf-8');
+        const failedChecks = result.checks.filter(c => !c.passed);
+        const feedback = failedChecks.map(c => `  - ${c.name}: ${c.details}`).join('\n');
+        const entry = `- Review failed (${new Date().toISOString().split('T')[0]}): ${failedChecks.length} check(s) failed\n${feedback}`;
+        if (content.includes('## Activity')) {
+            content = content.replace(/## Activity/, `## Activity\n${entry}`);
+        }
+        else {
+            content += `\n\n## Activity\n${entry}`;
+        }
+        writeFileSync(fullPath, content, 'utf-8');
+    }
+    catch {   }
+}
+function balancedObjectAt(text, start) {
+    const end = balancedObjectEnd(text, start);
+    return end === -1 ? null : text.slice(start, end);
+}
+export function extractReviewVerdict(output) {
+    return verdictFromFences(output) ?? lastTopLevelVerdict(output);
+}
+function verdictFromFences(output) {
+    const fenced = /```(?:json)?\s*([\s\S]*?)```/g;
+    let found = null;
+    for (let match = fenced.exec(output); match; match = fenced.exec(output)) {
+        const body = match[1].trim();
+        found = parseVerdictObject(body) ?? verdictInText(body) ?? found;
+    }
+    return found;
+}
+function verdictInText(text) {
+    const braced = text.indexOf('{');
+    if (braced === -1)
+        return null;
+    const obj = balancedObjectAt(text, braced);
+    return obj ? parseVerdictObject(obj) : null;
+}
+function lastTopLevelVerdict(output) {
+    let last = null;
+    let i = output.indexOf('{');
+    while (i !== -1) {
+        const obj = balancedObjectAt(output, i);
+        const parsed = obj?.includes('"passed"') ? parseVerdictObject(obj) : null;
+        if (obj && parsed) {
+            last = parsed;
+            i = output.indexOf('{', i + obj.length);
+            continue;
+        }
+        i = output.indexOf('{', i + 1);
+    }
+    return last;
+}
+export function parseReviewOutput(issueId, issueType, output) {
+    const parsed = extractReviewVerdict(output);
+    if (parsed) {
+        return {
+            issueId,
+            issueType,
+            passed: !!parsed.passed,
+            checks: Array.isArray(parsed.checks) ? parsed.checks.map((c) => ({
+                name: String(c.name ?? 'unknown'),
+                passed: !!c.passed,
+                details: String(c.details ?? ''),
+            })) : [],
+            reviewedAt: new Date().toISOString(),
+        };
+    }
+    return incompleteReviewResult(issueId, issueType, 'Could not parse review output');
+}
+export function hasFailedChecksWithoutDetails(result) {
+    if (result.passed || isIncompleteReview(result))
+        return false;
+    return result.checks.some((c) => !c.passed && c.details.trim().length === 0);
+}
+async function runDetailsFollowUp(options, issueType, verdict, previousOutput) {
+    const failedNames = verdict.checks.filter((c) => !c.passed).map((c) => c.name);
+    const prompt = [
+        `You reviewed issue ${options.issue.id} (${options.issue.title}) and returned this verdict:`,
+        '```',
+        previousOutput.slice(-4000),
+        '```',
+        '',
+        `The failed checks ${failedNames.join(', ')} carry no details. The implementing agent cannot act on a bare label.`,
+        'Restate the SAME verdict as one JSON object with, for every failed check, a specific `details` string naming what is wrong and what would satisfy the check (file, criterion, behaviour). Do not change which checks passed or failed.',
+        'Output EXACTLY one JSON object on its own line (no markdown fencing):',
+        '{"passed": false, "checks": [{"name": "criteria_met", "passed": false, "details": "..."}]}',
+    ].join('\n');
+    try {
+        const stream = createVerdictStream(options.onOutput);
+        const runner = createPlanRunner('review', {
+            workingDir: options.workingDir,
+            prompt,
+            engineId: REVIEW_GATE_ENGINE,
+            model: REVIEW_GATE_MODEL,
+            effortLevel: REVIEW_GATE_EFFORT_LEVEL,
+            verbose: true,
+            inferenceOnly: true,
+            policy: 'NONE',
+            outputCallback: (text) => stream.write(text),
+            extraEnv: options.extraEnv,
+            abortSignal: options.abortSignal,
+            logLabel: 'pm-review-details',
+            logDir: options.logDir,
+        });
+        const result = await runner.run().finally(() => stream.flush());
+        if (!result.completed || !result.assistantResponse)
+            return null;
+        const parsed = parseReviewOutput(options.issue.id, issueType, result.assistantResponse);
+        return isIncompleteReview(parsed) ? null : parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function incompleteReviewResult(issueId, issueType, reason) {
+    return {
+        issueId,
+        issueType,
+        passed: false,
+        checks: [{ name: REVIEW_INCOMPLETE_CHECK, passed: false, details: reason }],
+        reviewedAt: new Date().toISOString(),
+    };
+}
+export function isIncompleteReview(result) {
+    return !result.passed && result.checks.length === 1 && result.checks[0]?.name === REVIEW_INCOMPLETE_CHECK;
+}
+export const QUALITY_DELTA_CHECK = 'quality_delta';
+const BLOCKING_SEVERITIES = new Set(['critical', 'high']);
+const BLOCKING_CATEGORIES = new Set(['security', 'secrets', 'dependencies']);
+export const QUALITY_DELTA_PROMPT_MAX_FINDINGS = 25;
+export const QUALITY_DELTA_PROMPT_MAX_UNCHECKED = 20;
+export const QUALITY_DELTA_PROMPT_MAX_CHARS = 6_000;
+const QUALITY_DELTA_PROMPT_RESERVE = 800;
+const QUALITY_DELTA_PROMPT_UNCHECKED_SHARE = 1_200;
+const QUALITY_DELTA_PROMPT_CLIP = 200;
+const QUALITY_DELTA_CHECK_MAX_FINDINGS = 10;
+export function isBlockingQualityFinding(finding) {
+    return BLOCKING_SEVERITIES.has(finding.severity) || BLOCKING_CATEGORIES.has(finding.category);
+}
+function blockingQualityFindings(delta) {
+    if (!delta?.available || delta.gate !== 'block')
+        return [];
+    return delta.introduced.filter(isBlockingQualityFinding);
+}
+function clip(text, max) {
+    return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+function describeQualityFinding(finding) {
+    const where = finding.line === null ? finding.path : `${finding.path}:${finding.line}`;
+    return `[${finding.severity}] ${finding.category} ${where} — ${clip(finding.title, QUALITY_DELTA_PROMPT_CLIP)}`;
+}
+export function applyQualityGate(result, delta) {
+    if (isIncompleteReview(result))
+        return result;
+    const blockers = blockingQualityFindings(delta);
+    if (blockers.length === 0)
+        return result;
+    const listed = blockers.slice(0, QUALITY_DELTA_CHECK_MAX_FINDINGS).map(describeQualityFinding).join('; ');
+    const more = blockers.length > QUALITY_DELTA_CHECK_MAX_FINDINGS ? `; and ${blockers.length - QUALITY_DELTA_CHECK_MAX_FINDINGS} more` : '';
+    const details = `${blockers.length} introduced finding(s) fail the board's quality gate (block: critical or high severity, or category security / secrets / dependencies): ${listed}${more}. Fix each before the next review.`;
+    return {
+        ...result,
+        passed: false,
+        checks: [...result.checks.filter((c) => c.name !== QUALITY_DELTA_CHECK), { name: QUALITY_DELTA_CHECK, passed: false, details }],
+    };
+}
+function takeWithinBudget(items, render, budget) {
+    const lines = [];
+    for (const item of items) {
+        const line = render(item);
+        if (line.length + 1 > budget.left)
+            break;
+        lines.push(line);
+        budget.left -= line.length + 1;
+    }
+    return lines;
+}
+export function renderQualityDeltaSection(delta, boardDir) {
+    if (!delta) {
+        return "Not recorded for this issue — the board's `quality_gate` is `off`, or this run has no board. That is not evidence either way.";
+    }
+    if (!delta.available) {
+        return `Gate mode: ${delta.gate}. Unavailable — ${delta.reason}. No file was checked, so this is not a clean result: weigh the code on your own reading. An unavailable delta never fails a review.`;
+    }
+    const blocking = new Set(blockingQualityFindings(delta));
+    const budget = { left: QUALITY_DELTA_PROMPT_MAX_CHARS - QUALITY_DELTA_PROMPT_RESERVE - QUALITY_DELTA_PROMPT_UNCHECKED_SHARE };
+    const findingLines = takeWithinBudget(delta.introduced.slice(0, QUALITY_DELTA_PROMPT_MAX_FINDINGS), (finding) => {
+        const mark = blocking.has(finding) ? ' (BLOCKING)' : '';
+        const suggestion = finding.suggestion ? `\n  suggestion: ${clip(finding.suggestion, QUALITY_DELTA_PROMPT_CLIP)}` : '';
+        return `- ${describeQualityFinding(finding)}${mark}${suggestion}`;
+    }, budget);
+    budget.left += QUALITY_DELTA_PROMPT_UNCHECKED_SHARE;
+    const uncheckedLines = takeWithinBudget(delta.unchecked.slice(0, QUALITY_DELTA_PROMPT_MAX_UNCHECKED), (entry) => `- ${entry.path} — ${entry.reason}`, budget);
+    const record = boardDir ? join(qualityDeltaDir(boardDir), `${delta.issueId}-*.json`) : `<board>/quality/${delta.issueId}-*.json`;
+    const created = delta.createdFiles.length > 0 ? `, ${delta.createdFiles.length} created file(s) (every finding in a created file counts as introduced)` : '';
+    const lines = [
+        `Gate mode: ${delta.gate}. Baseline captured ${delta.baselineAt}; ${delta.checked.length} file(s) checked, ${delta.introducedCount} introduced finding(s), ${delta.unchecked.length} unchecked file(s)${created}.`,
+    ];
+    if (delta.introducedCount === 0) {
+        lines.push('No introduced findings.');
+    }
+    else {
+        if (delta.gate === 'block') {
+            lines.push(blocking.size > 0
+                ? `${blocking.size} of them fail this review whatever your verdict (critical or high severity, or category security / secrets / dependencies) — marked BLOCKING below.`
+                : 'None is critical or high, or in category security / secrets / dependencies, so the gate does not fail this review on its own.');
+        }
+        lines.push('', `Introduced findings, most severe first — showing ${findingLines.length} of ${delta.introducedCount} (this section is capped at ${QUALITY_DELTA_PROMPT_MAX_FINDINGS} findings and ${QUALITY_DELTA_PROMPT_MAX_CHARS} characters; the record at ${record} lists up to ${QUALITY_DELTA_MAX_FINDINGS}):`, ...findingLines);
+    }
+    if (delta.unchecked.length > 0) {
+        lines.push('', `Unchecked files — no analyzer read these, so they are unchecked, not clean (showing ${uncheckedLines.length} of ${delta.unchecked.length}):`, ...uncheckedLines);
+    }
+    return lines.join('\n');
+}
+function buildReviewPrompt(issue, pmDir, outputPath, isCodeTask, boardDir, workingDir, qualityDelta) {
+    const criteria = issue.acceptanceCriteria
+        .map(c => `- [${c.checked ? 'x' : ' '}] ${c.text}`)
+        .join('\n');
+    const criteriaStr = criteria || 'No specific criteria defined.';
+    const filesModified = issue.filesToModify.map(f => `- ${f}`).join('\n');
+    const issueSpecPath = join(pmDir, issue.path);
+    if (isCodeTask) {
+        const result = loadAgentPrompt('review-code', {
+            issue_id: issue.id,
+            issue_title: issue.title,
+            files_modified: filesModified,
+            acceptance_criteria: criteriaStr,
+            output_path: outputPath,
+            quality_delta: renderQualityDeltaSection(qualityDelta, boardDir),
+        }, boardDir, workingDir);
+        if (result)
+            return result;
+    }
+    const result = loadAgentPrompt('review-quality', {
+        issue_id: issue.id,
+        issue_title: issue.title,
+        output_path: outputPath,
+        issue_spec_path: issueSpecPath,
+        acceptance_criteria: criteriaStr,
+    }, boardDir, workingDir);
+    if (result)
+        return result;
+    return `You are a reviewer. Review the work done for issue ${issue.id}: ${issue.title}.\n\n## Acceptance Criteria\n${criteriaStr}\n\nOutput EXACTLY one JSON object on its own line (no markdown fencing):\n{"passed": true, "checks": [{"name": "criteria_met", "passed": true, "details": "..."}]}`;
+}
+export async function runReviewPipeline(options, callbacks) {
+    const { issue, pmDir, workingDir, executionDir, boardDir, extraEnv, abortSignal, qualityDelta } = options;
+    const reviewDir = boardDir ?? pmDir;
+    const attempts = getReviewAttemptCount(reviewDir, issue);
+    if (attempts >= MAX_REVIEW_ATTEMPTS) {
+        await callbacks.setStatus(issue.path, 'cancelled');
+        await appendCancellationNote(pmDir, issue, `Cancelled after ${MAX_REVIEW_ATTEMPTS} failed reviews — issue may need restructuring`, callbacks.warn);
+        callbacks.onReviewProgress(issue.id, 'max_attempts');
+        callbacks.onIssueAbandoned(issue.id, `Review failed ${MAX_REVIEW_ATTEMPTS} times — cancelled to unblock dependents`, attempts);
+        callbacks.onOutput(issue.id, 'Review: max attempts reached, cancelling issue to unblock dependents');
+        return false;
+    }
+    await callbacks.setStatus(issue.path, 'in_review');
+    callbacks.onReviewProgress(issue.id, 'reviewing');
+    const outputPath = resolveOutputPath(issue, workingDir, boardDir);
+    const reviewStart = Date.now();
+    const reviewSessionId = `improv-${reviewStart}-pm-${issue.id}-review`;
+    const result = await reviewIssue({
+        workingDir: executionDir || workingDir,
+        issue,
+        pmDir,
+        outputPath,
+        onOutput: (text) => callbacks.onOutput(issue.id, text),
+        onPrompt: (prompt) => callbacks.onReviewPrompt(issue.id, prompt),
+        onComplete: async (sessionResult, prompt) => {
+            persistTranscriptSession(workingDir, {
+                sessionId: reviewSessionId,
+                userPrompt: prompt,
+                result: sessionResult,
+                execStart: reviewStart,
+                engine: REVIEW_GATE_ENGINE,
+                model: REVIEW_GATE_MODEL,
+            });
+            await appendOutputHistoryEntry(pmDir, issue.path, {
+                sessionId: reviewSessionId,
+                title: `${issue.id} review`,
+                timestamp: new Date(reviewStart).toISOString(),
+                status: sessionResult.completed && !sessionResult.error ? 'done' : 'failed',
+            }, callbacks.warn);
+        },
+        logDir: boardDir ? join(boardDir, 'logs') : undefined,
+        boardDir,
+        extraEnv,
+        abortSignal,
+        qualityDelta,
+    });
+    const reviewFinish = Date.now();
+    if (!isIncompleteReview(result)) {
+        const stamped = { ...result, startedAt: new Date(reviewStart).toISOString(), finishedAt: new Date(reviewFinish).toISOString() };
+        persistReviewResult(reviewDir, issue, stamped);
+        callbacks.onReviewResult?.(issue.id, stamped);
+    }
+    if (result.passed) {
+        await callbacks.setStatus(issue.path, 'done');
+        callbacks.onReviewProgress(issue.id, 'passed');
+        callbacks.onIssueCompleted(issue);
+        return true;
+    }
+    if (isIncompleteReview(result)) {
+        callbacks.onOutput(issue.id, `Review: ${result.checks[0]?.details ?? 'incomplete'} — leaving for retry.`);
+        callbacks.onIssueError(issue.id, `Review incomplete: ${result.checks[0]?.details ?? 'no verdict'}`);
+        return false;
+    }
+    await callbacks.setStatus(issue.path, 'todo');
+    appendReviewFeedback(pmDir, issue, result);
+    callbacks.onReviewProgress(issue.id, 'failed');
+    callbacks.onIssueError(issue.id, `Review failed: ${result.checks.filter(c => !c.passed).map(c => c.name).join(', ')}`);
+    return false;
+}

package/dist/server/services/plan/review-report.js

@@ -0,0 +1,134 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export const REVIEW_INCOMPLETE_CHECK = 'review_incomplete';
+const CHECK_LABELS = {
+    criteria_met: 'Acceptance criteria',
+    code_quality: 'Code quality',
+    no_obvious_bugs: 'No obvious bugs',
+    output_quality: 'Output quality',
+    completeness: 'Completeness',
+    [REVIEW_INCOMPLETE_CHECK]: 'Review incomplete',
+};
+export function reviewCheckLabel(name) {
+    const known = CHECK_LABELS[name];
+    if (known)
+        return known;
+    const words = name.replace(/[_-]+/g, ' ').trim();
+    if (!words)
+        return 'Check';
+    return words.charAt(0).toUpperCase() + words.slice(1);
+}
+export function toReviewReport(result) {
+    const checks = Array.isArray(result.checks) ? result.checks : [];
+    const verdict = verdictOf(result, checks);
+    const sections = verdict === 'incomplete' ? [] : failuresFirst(checks).map(toSection);
+    return {
+        issueId: result.issueId,
+        issueType: result.issueType,
+        verdict,
+        passedCount: checks.filter(c => c.passed).length,
+        totalCount: checks.length,
+        failedLabels: sections.filter(s => !s.passed).map(s => s.label),
+        sections,
+        reviewedAt: result.reviewedAt,
+        autoPass: result.autoPass === true,
+        incompleteReason: verdict === 'incomplete' ? (checks[0]?.details ?? '').trim() : '',
+    };
+}
+const VERDICT_TITLES = {
+    passed: '✅ Review passed',
+    failed: '❌ Review failed',
+    incomplete: '⚠️ Review incomplete',
+};
+export class MarkdownReviewReportRenderer {
+    render(report) {
+        const lines = ['', '', '---', '', `### ${VERDICT_TITLES[report.verdict]} — ${report.issueId}`, '', subtitle(report), ''];
+        if (report.verdict === 'incomplete') {
+            lines.push(report.incompleteReason || 'The reviewer returned no verdict.', '', 'Nothing was marked done — the issue stays in review for a retry.', '');
+            return lines.join('\n');
+        }
+        for (const section of report.sections)
+            lines.push(...renderSection(section));
+        return lines.join('\n');
+    }
+}
+const defaultRenderer = new MarkdownReviewReportRenderer();
+export function renderReviewResultMarkdown(result, renderer = defaultRenderer) {
+    return renderer.render(toReviewReport(result));
+}
+function verdictOf(result, checks) {
+    if (result.passed)
+        return 'passed';
+    if (checks.length === 1 && checks[0]?.name === REVIEW_INCOMPLETE_CHECK)
+        return 'incomplete';
+    return 'failed';
+}
+function failuresFirst(checks) {
+    return [...checks.filter(c => !c.passed), ...checks.filter(c => c.passed)];
+}
+function toSection(check) {
+    return {
+        name: check.name,
+        label: reviewCheckLabel(check.name),
+        passed: check.passed,
+        details: (check.details ?? '').trim(),
+    };
+}
+function subtitle(report) {
+    const parts = [];
+    if (report.verdict === 'passed') {
+        parts.push(`**${report.passedCount} of ${report.totalCount} checks passed**`);
+    }
+    else if (report.verdict === 'failed') {
+        const failed = report.totalCount - report.passedCount;
+        const named = report.failedLabels.length > 0 ? ` — ${report.failedLabels.join(', ')}` : '';
+        parts.push(`**${failed} of ${report.totalCount} checks failed**${named}`);
+    }
+    parts.push(report.issueType === 'code' ? 'code review' : 'quality review');
+    if (report.autoPass)
+        parts.push('_auto-passed on an infrastructure failure_');
+    const when = formatReviewedAt(report.reviewedAt);
+    if (when)
+        parts.push(when);
+    return parts.join(' · ');
+}
+function renderSection(section) {
+    const head = `#### ${section.passed ? '✅' : '❌'} ${section.label}`;
+    const body = section.details ? renderDetailBody(section.details) : ['_The reviewer gave no reason._'];
+    return [head, '', ...body, ''];
+}
+export function renderDetailBody(details) {
+    const facets = splitEnumeratedFacets(details);
+    if (!facets)
+        return [details];
+    const out = [];
+    if (facets.preamble)
+        out.push(facets.preamble, '');
+    for (const item of facets.items)
+        out.push(`- **${item.label}** — ${item.text}`);
+    return out;
+}
+export function splitEnumeratedFacets(details) {
+    const marker = /(^|[\s([])(AC\s?\d+)\s*[:.]\s+/g;
+    const marks = [];
+    for (let m = marker.exec(details); m; m = marker.exec(details)) {
+        marks.push({ start: m.index + m[1].length, end: m.index + m[0].length, label: m[2].replace(/\s+/g, '') });
+    }
+    if (marks.length < 2)
+        return null;
+    const items = marks
+        .map((mark, i) => ({
+        label: mark.label,
+        text: details.slice(mark.end, i + 1 < marks.length ? marks[i + 1].start : details.length).trim(),
+    }))
+        .filter(item => item.text.length > 0);
+    if (items.length < 2)
+        return null;
+    return { preamble: details.slice(0, marks[0].start).trim(), items };
+}
+function formatReviewedAt(iso) {
+    const at = new Date(iso);
+    if (Number.isNaN(at.getTime()))
+        return '';
+    return `${at.toISOString().replace('T', ' ').slice(0, 16)} UTC`;
+}