@twistezo/ai-review-council 1.3.0 → 1.4.0

package/README.md

@@ -1,6 +1,6 @@
 # ai-review-council
 
-Runs independent Codex and Claude Code reviewers on a code change. A council agent verifies their findings and prints one Markdown report, also copied to the clipboard.
+Runs independent Codex and Claude Code reviewers on a code change. A council agent verifies their findings and writes one Markdown report, previewed in the terminal, ready to copy or open.
 
 Changes: [CHANGELOG.md](CHANGELOG.md). Internals: [ARCHITECTURE.md](ARCHITECTURE.md).
 
@@ -39,13 +39,14 @@ The review covers the branch checked out; switch branches before starting.
 | `Ctrl+D` | confirm the prompt |
 | `Ctrl+V` | paste into the prompt |
 | `Esc` | back |
+| `c` / `o` / `q` | after the review: copy the report / open it in the default `.md` app / quit |
 
 | Exit code | Meaning |
 |---|---|
-| `0` | Report printed; failed reviewers named on stderr |
+| `0` | Report shown, then `q`, `Esc` or `Ctrl+C`; failed reviewers named on stderr |
 | `1` | Requirements not met, or no verified report |
 | `2` | Invalid options; usage printed on stderr |
-| `130` / `129` / `143` | `Ctrl+C` / terminal closed / `kill`; agents stop and temp files go, confirmed by a message where the terminal remains |
+| `130` / `129` / `143` | `Ctrl+C` before the report / terminal closed / `kill`; agents stop and temp files go, confirmed by a message where the terminal remains |
 
 ## Agents
 

package/dist/app-services.js

@@ -1,5 +1,6 @@
 import { homedir } from 'node:os';
 import { createClipboardReader } from './clipboard/read-clipboard.js';
+import { writeClipboard } from './clipboard/write-clipboard.js';
 import { runAgent } from './execution/run-agent.js';
 import { createGitRepository } from './git/git-repository.js';
 import { findMissingInstructionFiles, instructionsDirectory, readInstructions } from './instructions/instruction-files.js';
@@ -7,6 +8,7 @@ import { startJsonLineProcess } from './process/json-line-process.js';
 import { runCommand } from './process/run-command.js';
 import { createClaudeAdapter } from './providers/claude-adapter.js';
 import { createCodexAdapter } from './providers/codex-adapter.js';
+import { createReportOpener } from './review/open-report.js';
 import { createWorkspacePreparer } from './review/review-workspace.js';
 // The real services: local CLIs, Git, the shipped instructions and the macOS clipboard.
 export const createAppServices = (cwd, appInfo) => {
@@ -19,6 +21,8 @@ export const createAppServices = (cwd, appInfo) => {
         ],
         findMissingInstructionFiles: () => findMissingInstructionFiles(instructionsDirectory),
         readClipboard: createClipboardReader(runCommand),
+        writeClipboard,
+        openReport: createReportOpener(runCommand),
         review: {
             runAgent,
             prepareWorkspace: createWorkspacePreparer(git),

package/dist/cli.js

@@ -36,6 +36,6 @@ const main = async () => {
             console.log(`\n${message}\n`);
         }
     }
-    process.exitCode = await printOutcome(result.outcome);
+    process.exitCode = printOutcome(result.outcome);
 };
 await main();

package/dist/execution/agent-events.js

@@ -30,8 +30,23 @@ const claudeEventSchema = z.discriminatedUnion('type', [
         subtype: z.string(),
         is_error: z.boolean().optional(),
         result: z.string().optional(),
+        usage: z
+            .object({
+            input_tokens: z.number().optional(),
+            cache_creation_input_tokens: z.number().optional(),
+            cache_read_input_tokens: z.number().optional(),
+            output_tokens: z.number().optional(),
+        })
+            .optional(),
     }),
 ]);
+const sumTokens = (counts) => {
+    let total = 0;
+    for (const count of counts) {
+        total += count ?? 0;
+    }
+    return total;
+};
 // Claude Code `--output-format stream-json`.
 export const parseClaudeLine = (line) => {
     const parsed = claudeEventSchema.safeParse(parseJson(line));
@@ -54,10 +69,27 @@ export const parseClaudeLine = (line) => {
                 : [];
         });
     }
+    // Claude Code counts cache writes and reads apart from fresh input.
+    const usage = event.usage === undefined
+        ? []
+        : [
+            {
+                kind: 'usage',
+                tokens: sumTokens([
+                    event.usage.input_tokens,
+                    event.usage.cache_creation_input_tokens,
+                    event.usage.cache_read_input_tokens,
+                    event.usage.output_tokens,
+                ]),
+            },
+        ];
     if (event.subtype === 'success' && event.is_error !== true) {
-        return [{ kind: 'completed', text: event.result ?? null }];
+        return [...usage, { kind: 'completed', text: event.result ?? null }];
     }
-    return [{ kind: 'error', message: `Claude Code ended with ${event.subtype}${event.result ? `: ${event.result}` : ''}` }];
+    return [
+        ...usage,
+        { kind: 'error', message: `Claude Code ended with ${event.subtype}${event.result ? `: ${event.result}` : ''}` },
+    ];
 };
 const codexEventSchema = z.discriminatedUnion('type', [
     z.object({ type: z.literal('thread.started'), thread_id: z.string() }),
@@ -69,7 +101,10 @@ const codexEventSchema = z.discriminatedUnion('type', [
         type: z.literal('item.completed'),
         item: z.object({ type: z.string(), text: z.string().optional() }),
     }),
-    z.object({ type: z.literal('turn.completed') }),
+    z.object({
+        type: z.literal('turn.completed'),
+        usage: z.object({ input_tokens: z.number().optional(), output_tokens: z.number().optional() }).optional(),
+    }),
     z.object({ type: z.literal('turn.failed'), error: z.object({ message: z.string() }) }),
     z.object({ type: z.literal('error'), message: z.string() }),
 ]);
@@ -89,8 +124,14 @@ export const parseCodexLine = (line) => {
             return event.item.type === 'agent_message' && event.item.text !== undefined && event.item.text.trim() !== ''
                 ? [{ kind: 'message', text: event.item.text }]
                 : [];
+        // Codex counts cached input inside `input_tokens`.
         case 'turn.completed':
-            return [{ kind: 'completed', text: null }];
+            return [
+                ...(event.usage === undefined
+                    ? []
+                    : [{ kind: 'usage', tokens: sumTokens([event.usage.input_tokens, event.usage.output_tokens]) }]),
+                { kind: 'completed', text: null },
+            ];
         case 'turn.failed':
             return [{ kind: 'error', message: `Codex turn failed: ${event.error.message}` }];
         case 'error':

package/dist/execution/agent-progress.js

@@ -2,6 +2,7 @@ export const waitingProgress = {
     phase: 'waiting',
     reads: 0,
     sessionId: null,
+    tokens: null,
     startedAt: null,
     finishedAt: null,
     note: null,
@@ -11,6 +12,8 @@ export const applyAgentEvent = (progress, event) => {
     switch (event.kind) {
         case 'session':
             return { ...progress, sessionId: event.sessionId };
+        case 'usage':
+            return { ...progress, tokens: (progress.tokens ?? 0) + event.tokens };
         case 'read':
             return { ...progress, phase: 'reading', reads: progress.reads + 1 };
         case 'message':

package/dist/print-outcome.js

@@ -1,27 +1,13 @@
-import { writeClipboard } from './clipboard/write-clipboard.js';
-import { formatReport } from './review/format-report.js';
 import { describeReviewResult } from './review/review-output.js';
-const defaultColumns = 80;
-// A full-width line between the progress table and the report.
-const separator = () => '─'.repeat(Math.max(1, (process.stdout.columns ?? defaultColumns) - 1));
-// The same formatted text is shown and copied.
-const printReport = async (rawReport) => {
-    const report = await formatReport(rawReport);
-    console.log(`\n${separator()}\n\n${report}\n\n${separator()}`);
-    const isCopied = await writeClipboard(report);
-    // the trailing empty line keeps the shell prompt apart from the message
-    console.log(`${isCopied ? '✔ Report copied to the clipboard.' : '✘ Could not copy the report to the clipboard.'}\n`);
-};
-// Prints what the run produced and returns the exit code.
-export const printOutcome = async (outcome) => {
+// Prints what the run left to say after the app closed and returns the exit code.
+// The report itself stays in the app's last frame as a preview, copied with `c`.
+export const printOutcome = (outcome) => {
     switch (outcome.kind) {
         case 'finished': {
-            const { stdout, stderr, exitCode } = describeReviewResult(outcome.result);
+            const { stderr, exitCode } = describeReviewResult(outcome.result);
             if (stderr !== null) {
-                console.error(`\n${stderr}`);
-            }
-            if (stdout !== null) {
-                await printReport(stdout);
+                // the trailing empty line keeps the shell prompt apart from the message
+                console.error(`\n${stderr}\n`);
             }
             return exitCode;
         }

package/dist/providers/claude-adapter.js

@@ -18,12 +18,16 @@ const initializeResponseSchema = z.object({
     ]),
 });
 const initializeRequestId = 'ai-review-council-catalog';
+const defaultModelAlias = 'default';
 export const parseClaudeInitializeResponse = (message) => {
     const { response } = initializeResponseSchema.parse(message);
     if (response.subtype === 'error') {
         throw new Error(`Claude Code initialize failed: ${response.error}`);
     }
-    return response.response.models.map((model) => ({
+    // `default` only points at a model already listed under its own name, e.g. Opus 5.5; kept when it is all there is.
+    const { models } = response.response;
+    const namedModels = models.filter((model) => model.value !== defaultModelAlias);
+    return (namedModels.length === 0 ? models : namedModels).map((model) => ({
         id: model.value,
         label: model.displayName || model.value,
         efforts: model.supportedEffortLevels ?? [],

package/dist/review/open-report.js

@@ -0,0 +1,17 @@
+import { mkdtemp, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { isSuccessful } from '../process/run-command.js';
+// Writes the report to a temporary Markdown file and opens it in the macOS default app for `.md`.
+// The file outlives the app, so the viewer keeps it after the review ends.
+export const createReportOpener = (run) => async (report) => {
+    try {
+        const directory = await mkdtemp(path.join(tmpdir(), 'ai-review-council-report-'));
+        const filePath = path.join(directory, 'review.md');
+        await writeFile(filePath, `${report}\n`);
+        return isSuccessful(await run('open', [filePath])) ? filePath : null;
+    }
+    catch {
+        return null;
+    }
+};

package/dist/review/report-preview.js

@@ -0,0 +1,26 @@
+import { proseLines } from './run-review.js';
+const headingText = (line, marker) => line.slice(marker.length).trim();
+// Built only from what every report keeps: the `# ` title, its first paragraph and the `### ` finding headings.
+// Section names and severity fields follow the report language and wording, so they are left out.
+export const previewReport = (report) => {
+    const lines = proseLines(report);
+    const titleIndex = lines.findIndex(({ line }) => line.startsWith('# '));
+    const title = titleIndex === -1 ? null : headingText(lines[titleIndex]?.line ?? '', '# ');
+    const afterTitle = lines.slice(titleIndex + 1);
+    const firstFinding = afterTitle.findIndex(({ line }) => line.startsWith('### '));
+    const beforeFindings = firstFinding === -1 ? afterTitle : afterTitle.slice(0, firstFinding);
+    const paragraphStart = beforeFindings.findIndex(({ line }) => line.trim() !== '' && !line.startsWith('#'));
+    const paragraph = [];
+    for (const { line } of paragraphStart === -1 ? [] : beforeFindings.slice(paragraphStart)) {
+        if (line.trim() === '' || line.startsWith('#')) {
+            break;
+        }
+        paragraph.push(line.trim());
+    }
+    return {
+        title,
+        summary: paragraph.length === 0 ? null : paragraph.join(' '),
+        findings: lines.filter(({ line }) => line.startsWith('### ')).map(({ line }) => headingText(line, '### ')),
+        lineCount: report.split('\n').length,
+    };
+};

package/dist/review/run-review.js

@@ -13,7 +13,7 @@ const isFence = (line) => {
     return trimmed.startsWith('```') || trimmed.startsWith('~~~');
 };
 // Lines outside fenced code blocks; a `#` in a code sample is not a heading.
-const proseLines = (text) => {
+export const proseLines = (text) => {
     let isInCodeBlock = false;
     return text
         .split('\n')

package/dist/ui/app.js

@@ -68,6 +68,7 @@ export const App = ({ title, services, presets, timeoutMinutes, onFinish }) => {
     const { exit } = useApp();
     const [state, setState] = useState({
         step: 'preflight',
+        isGoingBack: false,
         skipped: presetSkips(presets),
         checks: [],
         models: [],
@@ -85,10 +86,17 @@ export const App = ({ title, services, presets, timeoutMinutes, onFinish }) => {
         exit();
     };
     const complete = (patch) => {
-        setState((previous) => ({ ...previous, ...patch, step: nextStep(previous.step, previous.skipped) }));
+        setState((previous) => ({
+            ...previous,
+            ...patch,
+            step: nextStep(previous.step, previous.skipped),
+            isGoingBack: false,
+        }));
     };
     const previous = previousStep(state.step, state.skipped);
-    const back = previous === null ? undefined : () => setState((current) => ({ ...current, step: previous }));
+    const back = previous === null
+        ? undefined
+        : () => setState((current) => ({ ...current, step: previous, isGoingBack: true }));
     // A preset step that was skipped is shown when its value turned out invalid.
     const isAutoSubmit = state.step === 'project' && state.skipped.includes('project');
     const renderStep = () => {
@@ -104,7 +112,7 @@ export const App = ({ title, services, presets, timeoutMinutes, onFinish }) => {
             case 'council':
                 return (_jsx(CouncilStep, { models: state.models, value: state.council, onSubmit: (council) => complete({ council }), onBack: back }));
             case 'reviewers':
-                return (_jsx(ReviewersStep, { models: state.models, value: state.reviewers, presetCount: presets.reviewerCount, onSubmit: (reviewers) => complete({ reviewers }), onBack: back }));
+                return (_jsx(ReviewersStep, { models: state.models, value: state.reviewers, resumeAtLast: state.isGoingBack, presetCount: presets.reviewerCount, onSubmit: (reviewers) => complete({ reviewers }), onBack: back }));
             case 'prompt':
                 return (_jsx(PromptStep, { value: state.prompt, readClipboard: services.readClipboard, onSubmit: (prompt) => complete({ prompt }), onBack: back }));
             case 'summary': {
@@ -126,5 +134,5 @@ export const App = ({ title, services, presets, timeoutMinutes, onFinish }) => {
     const { columns } = useWindowSize();
     const steps = numberedSteps(state.skipped);
     const stepNumber = state.running === null ? steps.indexOf(state.step) + 1 : 0;
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, color: theme.title, children: title }), state.checks.length > 0 && (_jsx(Box, { marginTop: 1, children: _jsx(RequirementsLine, { checks: state.checks }) })), _jsx(Text, { dimColor: true, children: '─'.repeat(Math.max(1, Math.min(separatorWidth, columns - screenPadding))) }), _jsx(Box, { marginTop: 1, children: state.running === null ? (_jsx(StepCounterContext.Provider, { value: stepNumber > 0 ? `step ${stepNumber} of ${steps.length}` : null, children: _jsx(StepAnswersContext.Provider, { value: stepFields[state.step] === undefined ? null : (_jsx(AnswersPanel, { answers: answersBefore(state), selecting: stepFields[state.step] ?? null })), children: renderStep() }) })) : (_jsx(RunScreen, { session: state.running, dependencies: services.review, onFinished: finish })) })] }));
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, color: theme.title, children: title }), state.checks.length > 0 && (_jsx(Box, { marginTop: 1, children: _jsx(RequirementsLine, { checks: state.checks }) })), _jsx(Text, { dimColor: true, children: '─'.repeat(Math.max(1, Math.min(separatorWidth, columns - screenPadding))) }), _jsx(Box, { marginTop: 1, children: state.running === null ? (_jsx(StepCounterContext.Provider, { value: stepNumber > 0 ? `step ${stepNumber} of ${steps.length}` : null, children: _jsx(StepAnswersContext.Provider, { value: stepFields[state.step] === undefined ? null : (_jsx(AnswersPanel, { answers: answersBefore(state), selecting: stepFields[state.step] ?? null })), children: renderStep() }) })) : (_jsx(RunScreen, { session: state.running, dependencies: services.review, writeClipboard: services.writeClipboard, openReport: services.openReport, onFinished: finish, onReported: onFinish, onQuit: exit })) })] }));
 };

package/dist/ui/components/report-result.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import { useEffect, useState } from 'react';
+import { formatReport } from '../../review/format-report.js';
+import { previewReport } from '../../review/report-preview.js';
+import { theme } from '../theme.js';
+const working = (text) => ({ text, color: theme.muted });
+const succeeded = (text) => ({ text: `✔ ${text}`, color: theme.success });
+const failed = (text) => ({ text: `✘ ${text}`, color: theme.failure });
+// A short preview of the report; the full text is copied or opened on request.
+export const ReportResult = ({ report, writeClipboard, openReport, onQuit }) => {
+    const [status, setStatus] = useState(null);
+    const [isBusy, setIsBusy] = useState(false);
+    const [isQuitting, setIsQuitting] = useState(false);
+    const { title, summary, findings, lineCount } = previewReport(report);
+    // Quits once the hints are gone, so the frame left behind shows no keys that no longer work.
+    useEffect(() => {
+        if (isQuitting) {
+            onQuit();
+        }
+    }, [isQuitting]);
+    // Copy and open both use the Prettier formatting, so the Markdown stays tidy.
+    const runAction = (pending, action) => {
+        setIsBusy(true);
+        setStatus(working(pending));
+        void formatReport(report)
+            .then(action)
+            .then((result) => {
+            setStatus(result);
+            setIsBusy(false);
+        });
+    };
+    useInput((input, key) => {
+        if (input === 'c' && !isBusy) {
+            runAction('Copying…', async (formatted) => (await writeClipboard(formatted))
+                ? succeeded('Report copied to the clipboard.')
+                : failed('Could not copy the report to the clipboard.'));
+        }
+        else if (input === 'o' && !isBusy) {
+            runAction('Opening…', async (formatted) => {
+                const filePath = await openReport(formatted);
+                return filePath === null ? failed('Could not open the report.') : succeeded(`Report opened: ${filePath}`);
+            });
+        }
+        else if (input === 'q' || key.escape) {
+            setIsQuitting(true);
+        }
+    }, { isActive: !isQuitting });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.muted, paddingX: 1, children: [_jsx(Text, { bold: true, color: theme.title, children: "Report" }), title !== null && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { bold: true, children: title }) })), summary !== null && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { children: summary }) })), findings.length > 0 && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: findings.map((finding, index) => (_jsxs(Text, { children: ["\u2022 ", finding] }, index))) })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["\u2026 ", lineCount, " lines in the full report"] }) })] }), status !== null && _jsx(Text, { color: status.color, children: status.text }), !isQuitting && _jsx(Text, { dimColor: true, children: "c copy \u00B7 o open \u00B7 q quit" })] }));
+};

package/dist/ui/run-progress.js

@@ -18,10 +18,21 @@ export const formatElapsed = ({ startedAt, finishedAt }, now) => {
     const seconds = totalSeconds % 60;
     return hours > 0 ? `${hours}:${pad(minutes)}:${pad(seconds)}` : `${pad(minutes)}:${pad(seconds)}`;
 };
+// Every Read, Grep or Glob call, or Codex shell command, so reading and searching alike.
+const countLookups = (count) => (count === 1 ? '1 lookup' : `${count} lookups`);
+// Rounded for a glance, e.g. `850 tokens`, `312k tokens`, `1.2M tokens`.
+const formatTokens = (count) => {
+    if (count < 1_000) {
+        return `${count} tokens`;
+    }
+    // 999,600 rounds up to a million, not to `1000k`.
+    return count < 999_500 ? `${Math.round(count / 1_000)}k tokens` : `${(count / 1_000_000).toFixed(1)}M tokens`;
+};
+const joinStatus = (parts) => parts.filter((part) => part !== null).join(' · ');
 const reviewerRows = (rows) => rows.filter((row) => !row.isCouncil);
 // One short phrase per row: the general step, never individual tool calls.
 export const describeStatus = (row, rows) => {
-    const { phase, reads, note } = row.progress;
+    const { phase, reads, tokens, note } = row.progress;
     switch (phase) {
         case 'waiting': {
             if (!row.isCouncil) {
@@ -34,13 +45,15 @@ export const describeStatus = (row, rows) => {
         case 'starting':
             return 'starting';
         case 'reading':
-            return row.isCouncil ? `verifying (${reads} reads)` : `reading code (${reads})`;
+            return `${row.isCouncil ? 'verifying' : 'reading code'} · ${countLookups(reads)}`;
         case 'writing':
             return 'writing report';
+        // A failed run can still cost tokens, so both show what the provider reported. A failure reason is long and
+        // the cell cuts its end, so the tokens go before it.
         case 'done':
-            return note === null ? 'done' : `done · ${note}`;
+            return joinStatus(['done', note, tokens === null ? null : formatTokens(tokens)]);
         case 'failed':
-            return `failed · ${note ?? 'unknown error'}`;
+            return joinStatus(['failed', tokens === null ? null : formatTokens(tokens), note ?? 'unknown error']);
     }
 };
 const compareText = (left, right) => left.localeCompare(right, 'en', { sensitivity: 'base' });

package/dist/ui/steps/reviewers-step.js

@@ -23,10 +23,16 @@ const resize = (models, reviewers, count) => {
     const fresh = choiceToConfiguration(models, choiceFromConfiguration(models, null));
     return fresh === null ? [...reviewers] : resizeReviewers(reviewers, count, fresh);
 };
-export const ReviewersStep = ({ models, value, presetCount, onSubmit, onBack }) => {
+export const ReviewersStep = ({ models, value, resumeAtLast, presetCount, onSubmit, onBack, }) => {
     const [reviewers, setReviewers] = useState(() => presetCount === null ? [...value] : resize(models, value, presetCount));
     // null shows the count question; a number edits that reviewer. `--reviewers` skips the question.
-    const [editing, setEditing] = useState(presetCount === null ? null : 0);
+    // Esc from the prompt opens the last reviewer, with every choice kept.
+    const [editing, setEditing] = useState(() => {
+        if (resumeAtLast && value.length > 0) {
+            return reviewers.length - 1;
+        }
+        return presetCount === null ? null : 0;
+    });
     if (editing === null) {
         return (_jsxs(StepFrame, { title: "Reviewers", hints: "\u2191\u2193 row \u00B7 Enter confirm", onBack: onBack, children: [_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { dimColor: true, children: "How many reviewers? Each works independently." }), _jsx(Text, { dimColor: true, children: "Mix providers and models to catch more." })] }), _jsx(SelectList, { items: Array.from({ length: maxReviewers }, (_, index) => ({
                         key: String(index + 1),

package/dist/ui/steps/run-screen.js

@@ -5,6 +5,8 @@ import { waitingProgress } from '../../execution/agent-progress.js';
 import { formatEffort } from '../../providers/model-catalog.js';
 import { providerDisplayNames } from '../../providers/provider-adapter.js';
 import { councilAgentId, numberReviewers, reviewerAgentId, runReview } from '../../review/run-review.js';
+import { describeReviewResult } from '../../review/review-output.js';
+import { ReportResult } from '../components/report-result.js';
 import { RunProgress } from '../components/run-progress.js';
 const agentColumns = (configuration) => ({
     provider: providerDisplayNames[configuration.provider],
@@ -28,19 +30,29 @@ const initialRunRows = (reviewers, council) => [
     },
 ];
 // Starts the review once; leaving the screen (Ctrl+C) cancels every running agent.
-export const RunScreen = ({ session, dependencies, onFinished }) => {
+export const RunScreen = ({ session, dependencies, writeClipboard, openReport, onFinished, onReported, onQuit, }) => {
     const [rows, setRows] = useState(() => initialRunRows(numberReviewers(session.reviewers), session.council));
     const [outcome, setOutcome] = useState(null);
-    // Reported after the final statuses are on screen, so the frame left behind shows them.
+    const report = outcome?.kind === 'finished' ? describeReviewResult(outcome.result).stdout : null;
+    // Reported after the final statuses are on screen, so the frame left behind shows them. With a report the app
+    // waits for a key, but the outcome is already known: Ctrl+C there quits like `q`, not as a cancelled review.
     useEffect(() => {
-        if (outcome !== null) {
+        if (outcome === null) {
+            return;
+        }
+        if (report === null) {
             onFinished(outcome);
         }
+        else {
+            onReported(outcome);
+        }
     }, [outcome]);
     useEffect(() => {
         const controller = new AbortController();
         runReview(session, dependencies, (agentId, change) => setRows((previous) => previous.map((row) => (row.id === agentId ? { ...row, progress: change(row.progress) } : row))), controller.signal).then((result) => setOutcome({ kind: 'finished', result }), (error) => setOutcome({ kind: 'failed', error: error instanceof Error ? error.message : String(error) }));
         return () => controller.abort();
     }, []);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Reviewing ", session.scope.changedFiles.length, " file(s) \u00B7 Ctrl+C cancels all agents"] }), _jsx(Box, { marginTop: 1, children: _jsx(RunProgress, { rows: rows }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: outcome === null
+                    ? `Reviewing ${session.scope.changedFiles.length} file(s) · Ctrl+C cancels all agents`
+                    : `Reviewed ${session.scope.changedFiles.length} file(s)` }), _jsx(Box, { marginTop: 1, children: _jsx(RunProgress, { rows: rows }) }), outcome !== null && report !== null && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(ReportResult, { report: report, writeClipboard: writeClipboard, openReport: openReport, onQuit: onQuit }) }))] }));
 };

package/dist/ui/steps/summary-step.js

@@ -23,7 +23,7 @@ export const SummaryStep = ({ session, onAction }) => {
     const { repository, reviewers } = session;
     const [firstPromptLine = '', ...otherPromptLines] = summarizePrompt(session.prompt);
     return (_jsxs(StepFrame, { title: "Summary", hints: "\u2191\u2193 row \u00B7 Enter confirm", children: [_jsx(Field, { label: "Language", children: reportLanguageNames[session.language] }), _jsx(Field, { label: "Project", children: repository.root }), _jsx(Field, { label: "Branch", children: repository.branch ?? 'detached HEAD' }), _jsx(Field, { label: "Working tree", children: repository.hasChanges ? (_jsx(Text, { color: theme.warning, children: "currently has uncommitted changes" })) : (_jsx(Text, { color: theme.success, children: "currently clean" })) }), _jsx(Field, { label: "Scope", children: describeScope(session.scope) }), _jsx(Field, { label: "Council", children: formatConfiguration(session.council) }), _jsx(Field, { label: "Reviewers", children: String(reviewers.length) }), _jsx(Box, { paddingLeft: labelWidth, children: _jsx(ReviewerList, { reviewers: reviewers }) }), _jsx(Field, { label: "Prompt", children: session.prompt === '' ? _jsx(Text, { dimColor: true, children: "none, review of the code alone" }) : firstPromptLine }), otherPromptLines.map((line, index) => (_jsx(Box, { paddingLeft: labelWidth, children: _jsx(Text, { children: line }) }, index))), _jsxs(Field, { label: "Timeout", children: [session.timeoutMinutes, " min per agent"] }), _jsx(Box, { marginTop: 1, children: _jsx(SelectList, { items: [
-                        { key: 'start', label: 'Start review' },
+                        { key: 'start', label: 'Start' },
                         { key: 'back', label: 'Back' },
                         { key: 'cancel', label: 'Cancel' },
                     ], onSelect: (key) => onAction(key === 'start' || key === 'back' ? key : 'cancel') }) })] }));

package/docs/council/council.md

@@ -5,4 +5,16 @@ You verify independent reviews against the supplied change and produce one trust
 - Verify every claim, merge duplicates and resolve contradictions. Separate confirmed findings, rejected claims with reasons and unresolved questions with missing evidence.
 - Preserve evidence, repository-relative locations, attribution, smallest fixes and coverage gaps. Include severity and confidence; prioritize by impact. Mark incidental new findings as council.
 - Return only a self-contained Markdown report in the session language. State when no issues were confirmed.
-- Start with a level-1 title, without an enclosing code fence. Use level-3 headings only for confirmed findings; the application counts them.
+- Use level-3 headings only for confirmed findings, most severe first; the application counts them and lists them in its preview.
+
+## Report opening
+
+The application previews the title, the first paragraph and the finding headings. Open the report like this, translated, without an enclosing code fence:
+
+```markdown
+# <one-line verdict>
+
+<n> confirmed: <n> critical, <n> high, <n> medium, <n> low. <What to fix first, in one sentence.>
+
+### <severity> · <finding title>
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@twistezo/ai-review-council",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Terminal app that runs independent Codex and Claude Code reviewers and merges their results",
   "license": "MIT",
   "keywords": [