-
- {/* Row-cap expander — only when the wrapped chips exceed the collapsed
- height, so a short strip carries no dangling control. */}
- {overflowing && (
-
-
-
- )}
-
- );
-}
diff --git a/app/src/components/FindingsPanel.tsx b/app/src/components/FindingsPanel.tsx
index 8c02ed9..0f0edd2 100644
--- a/app/src/components/FindingsPanel.tsx
+++ b/app/src/components/FindingsPanel.tsx
@@ -2,7 +2,7 @@
* Pre-review findings band — a collapsible triage list of every advisory
* finding the read-only pre-pass reviewer produced for this review.
*
- * It lives in the diff band stack directly below the {@link EvidenceStrip} and
+ * It lives in the diff band stack (below the persistent agent strip) and
* exists because the Monaco finding pins only appear once the reviewer selects
* the finding's file — findings on unselected files (and file-level findings
* whose lines never map into a visible hunk) were otherwise invisible. This
diff --git a/app/src/components/IntentPanel.test.tsx b/app/src/components/IntentPanel.test.tsx
deleted file mode 100644
index 5bf4cc5..0000000
--- a/app/src/components/IntentPanel.test.tsx
+++ /dev/null
@@ -1,83 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { render, screen } from "@testing-library/react";
-import { IntentPanel } from "./IntentPanel";
-
-// The panel renders markdown through the shared component, which imports the
-// opener plugin; stub it so no real IPC fires.
-vi.mock("@tauri-apps/plugin-opener", () => ({
- openUrl: vi.fn(() => Promise.resolve()),
-}));
-
-/** A no-op handler for the callbacks these tests don't exercise. */
-const noop = () => {
- /* no-op */
-};
-
-describe("IntentPanel", () => {
- it("renders the agent's read section when a distilled intent is present", () => {
- render(
- ,
- );
- expect(screen.getByText(/Agent's read/i)).toBeInTheDocument();
- expect(
- screen.getByText(/swaps the cache from LRU to LFU/),
- ).toBeInTheDocument();
- });
-
- it("omits the agent's read section when distilled intent is null", () => {
- render(
- ,
- );
- expect(screen.queryByText(/Agent's read/i)).not.toBeInTheDocument();
- });
-
- it("renders the agent's read as markdown (bold visible, no literal **)", () => {
- render(
- ,
- );
- expect(screen.getByText("LRU")).toBeInTheDocument();
- expect(screen.queryByText(/\*\*LRU\*\*/)).not.toBeInTheDocument();
- });
-
- it("shows the agent's read even when the author's description is empty", () => {
- render(
- ,
- );
- // The empty author body falls back to "No description.", but the agent's
- // read is still surfaced — the panel no longer hides purely on empty body.
- expect(screen.getByText("No description.")).toBeInTheDocument();
- expect(screen.getByText(/Adds retry with backoff/)).toBeInTheDocument();
- });
-});
diff --git a/app/src/components/IntentPanel.tsx b/app/src/components/IntentPanel.tsx
deleted file mode 100644
index 8de5b01..0000000
--- a/app/src/components/IntentPanel.tsx
+++ /dev/null
@@ -1,126 +0,0 @@
-/**
- * Collapsible "Intent" disclosure for the diff gate header (D4).
- *
- * Surfaces the PR description (`review.body`) as constrained, webview-safe
- * markdown (via the shared {@link Markdown} component — raw HTML dropped, links
- * routed externally) together with the Linear issue reference. Collapsed by
- * default; the open state is owned by the parent so it can be remembered per
- * review.
- *
- * When the pre-review agent produced a distilled read of what the PR actually
- * does, it is shown in the shared agent voice ({@link AgentCallout}, eyebrow
- * "AGENT'S READ"), clearly attributed as the agent's distillation (advisory)
- * rather than the author's description.
- */
-
-import { ChevronDown, ChevronRight, FileText, Hash } from "lucide-react";
-import { Markdown } from "./Markdown";
-import { AgentCallout } from "./AgentCallout";
-import { cn } from "@/lib/utils";
-
-interface IntentPanelProps {
- /** The PR description body. May be empty. */
- readonly body: string;
- /**
- * The pre-review agent's distilled read of what the PR actually does, or null
- * when the pre-pass has not run. Advisory display context, never the author's
- * words.
- */
- readonly distilledIntent: string | null;
- /** The Linear issue reference (e.g. `NEX-123`). */
- readonly issue: string;
- /** External URL for the issue, or null if it does not look like a Linear ref. */
- readonly issueHref: string | null;
- /** Whether the disclosure is expanded. */
- readonly open: boolean;
- /** Toggle the expanded state. */
- readonly onToggle: () => void;
- /** Open the issue in the external browser. */
- readonly onOpenIssue: (href: string) => void;
-}
-
-/**
- * A single-band disclosure showing the PR intent (body + issue) beneath the
- * diff-gate header.
- */
-export function IntentPanel({
- body,
- distilledIntent,
- issue,
- issueHref,
- open,
- onToggle,
- onOpenIssue,
-}: IntentPanelProps) {
- const trimmedBody = body.trim();
-
- return (
-
- );
-}
diff --git a/app/src/components/ReviewCard.test.tsx b/app/src/components/ReviewCard.test.tsx
index 9aa258e..9c99dd0 100644
--- a/app/src/components/ReviewCard.test.tsx
+++ b/app/src/components/ReviewCard.test.tsx
@@ -2,7 +2,12 @@ import { describe, it, expect, vi } from "vitest";
import { render, screen } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { ReviewCard } from "./ReviewCard";
-import { makeReview, makeAgentRun, ALL_GATE_STATES } from "../test/fixtures";
+import {
+ makeReview,
+ makeAgentRun,
+ makeFinding,
+ ALL_GATE_STATES,
+} from "../test/fixtures";
/** A diff adding `n` lines to `path`, for exercising the risk chips. */
function addLines(path: string, n: number): string {
@@ -223,4 +228,68 @@ describe("ReviewCard", () => {
expect(screen.getByText(/needs your review/i)).toBeInTheDocument();
expect(screen.getByText(/CI failing/)).toBeInTheDocument();
});
+
+ it("shows severity chips for critical and warning findings (INFO omitted)", () => {
+ render(
+ ,
+ );
+ expect(screen.getByText("2 CRIT")).toBeInTheDocument();
+ expect(screen.getByText("1 WARN")).toBeInTheDocument();
+ // Info never surfaces on the board cards.
+ expect(screen.queryByText(/INFO/)).not.toBeInTheDocument();
+ });
+
+ it("omits severity chips when there are no findings", () => {
+ render(
+ ,
+ );
+ expect(screen.queryByText(/CRIT/)).not.toBeInTheDocument();
+ expect(screen.queryByText(/WARN/)).not.toBeInTheDocument();
+ });
+
+ it("escalates the reason line for a critical finding", () => {
+ render(
+ ,
+ );
+ expect(screen.getByText(/agent flagged 1 critical/i)).toBeInTheDocument();
+ });
+
+ it("does not escalate the reason line for warning-only findings", () => {
+ render(
+ ,
+ );
+ expect(screen.queryByText(/agent flagged/i)).not.toBeInTheDocument();
+ // The warning still surfaces as a chip.
+ expect(screen.getByText("1 WARN")).toBeInTheDocument();
+ });
});
diff --git a/app/src/components/ReviewCard.tsx b/app/src/components/ReviewCard.tsx
index fa88b8a..154ecdc 100644
--- a/app/src/components/ReviewCard.tsx
+++ b/app/src/components/ReviewCard.tsx
@@ -9,6 +9,7 @@ import type { RiskFlag } from "../bindings/RiskFlag";
import type { CiSummary } from "../bindings/CiSummary";
import { cardSignal } from "../lib/card-signal";
import type { SignalTone } from "../lib/card-signal";
+import { findingCounts } from "../lib/finding-severity";
import { stripMarkdown } from "../lib/markdown-text";
import { diffStats } from "../diff-parser";
import { ciState } from "../lib/ci";
@@ -73,6 +74,8 @@ function toneTextClass(tone: SignalTone): string {
return "text-state-dispatched";
case "warning":
return "text-warning";
+ case "danger":
+ return "text-danger";
case "done":
return "text-state-approved";
case "neutral":
@@ -318,12 +321,46 @@ function RiskChips({ review }: { readonly review: Review }) {
};
}, [review.diff.raw]);
+ // Advisory pre-review finding counts, straight from the review (no dismissal
+ // concept on the board). INFO is omitted on cards — only Critical / Warning
+ // carry routing signal at a glance.
+ const findings = useMemo(
+ () => findingCounts(review.review_findings),
+ [review.review_findings],
+ );
+
const ci = review.ci_summary;
// F6: nudge splitting once a diff crosses 400 changed lines.
const oversized = signals.total > 400;
return (
<>
+ {findings.critical > 0 && (
+
+
+ {String(findings.critical)} CRIT
+
+
+ )}
+
+ {findings.warning > 0 && (
+
+
+ {String(findings.warning)} WARN
+
+
+ )}
+
{ci !== null && ci.total > 0 && (
)}
+ {/* A leading danger dot marks a critical-findings escalation (the only
+ source of the danger tone); it reads as red-dot + red text. */}
+ {signal.tone === "danger" && (
+
+ )}
{signal.reason}
@@ -497,7 +542,15 @@ export function ReviewCard({
{/* Reason line — the card's headline signal, with an optional risk
note layered under the gate reason on the same line. */}
-
+
+ {/* A leading danger dot marks a critical-findings escalation (the
+ only source of the danger tone); red-dot + red uppercase text. */}
+ {signal.tone === "danger" && (
+
+ )}
{signal.reason}
{signal.note !== undefined && (
diff --git a/app/src/components/ReviewWorkspace.tsx b/app/src/components/ReviewWorkspace.tsx
index 3236754..77b6c33 100644
--- a/app/src/components/ReviewWorkspace.tsx
+++ b/app/src/components/ReviewWorkspace.tsx
@@ -170,6 +170,11 @@ export function ReviewWorkspace({
setActiveTab("agent");
}, []);
+ // The Diff tab's persistent agent strip links back to the full Briefing.
+ const openBriefingTab = useCallback(() => {
+ setActiveTab("briefing");
+ }, []);
+
const switchToShellTab = useCallback(() => {
setActiveTab("shell");
}, []);
@@ -287,6 +292,7 @@ export function ReviewWorkspace({
onRequestChanges={onRequestChanges}
onMirrorComments={onMirrorComments}
onOpenAgent={openAgentTab}
+ onOpenBriefing={openBriefingTab}
/>
)}
diff --git a/app/src/lib/card-signal.test.ts b/app/src/lib/card-signal.test.ts
index f7abb57..21358e2 100644
--- a/app/src/lib/card-signal.test.ts
+++ b/app/src/lib/card-signal.test.ts
@@ -1,6 +1,6 @@
import { describe, it, expect } from "vitest";
import { cardSignal } from "./card-signal";
-import { makeReview } from "../test/fixtures";
+import { makeReview, makeFinding } from "../test/fixtures";
import type { CiSummary } from "../bindings/CiSummary";
/** A diff adding `n` lines to `path`. */
@@ -56,3 +56,98 @@ describe("cardSignal — risk note layering", () => {
expect(approved.note).toBeUndefined();
});
});
+
+describe("cardSignal — critical-findings escalation", () => {
+ const CRITICAL = makeFinding({ id: "c1", severity: "Critical" });
+ const WARNING = makeFinding({ id: "w1", severity: "Warning" });
+
+ it("escalates the reason line to danger tone for ≥1 critical finding", () => {
+ const signal = cardSignal(
+ makeReview({ gate_state: "InReview", review_findings: [CRITICAL] }),
+ );
+ expect(signal.tone).toBe("danger");
+ expect(signal.reason).toBe("Needs your review · Agent flagged 1 critical");
+ // The whole line is red, so the count is folded into the reason (not a
+ // muted note that would render grey).
+ expect(signal.note).toBeUndefined();
+ });
+
+ it("pluralizes the flagged count in the reason", () => {
+ const signal = cardSignal(
+ makeReview({
+ gate_state: "Pending",
+ review_findings: [CRITICAL, makeFinding({ id: "c2", severity: "Critical" })],
+ }),
+ );
+ expect(signal.reason).toBe("Needs your review · Agent flagged 2 critical");
+ });
+
+ it("escalates a reworked review while keeping its gate headline", () => {
+ const signal = cardSignal(
+ makeReview({ gate_state: "Reworked", review_findings: [CRITICAL] }),
+ );
+ expect(signal.tone).toBe("danger");
+ expect(signal.reason).toBe(
+ "Agent reworked — re-review · Agent flagged 1 critical",
+ );
+ });
+
+ it("does NOT escalate for warning-only findings (chips only)", () => {
+ const signal = cardSignal(
+ makeReview({ gate_state: "InReview", review_findings: [WARNING] }),
+ );
+ expect(signal.tone).toBe("attention");
+ expect(signal.reason).toBe("Needs your review");
+ expect(signal.note).toBeUndefined();
+ });
+
+ it("keeps CI failing first — a broken build outranks a critical escalation", () => {
+ const signal = cardSignal(
+ makeReview({
+ gate_state: "InReview",
+ ci_summary: CI_FAIL,
+ review_findings: [CRITICAL],
+ }),
+ );
+ // CI failing pins the reason line; the critical finding stays a chip only.
+ expect(signal.reason).toBe("Needs your review");
+ expect(signal.tone).toBe("attention");
+ expect(signal.note).toBe("CI failing");
+ });
+
+ it("stale review outranks a critical escalation", () => {
+ const signal = cardSignal(
+ makeReview({
+ stale: true,
+ gate_state: "InReview",
+ review_findings: [CRITICAL],
+ }),
+ );
+ expect(signal.reason).toBe("Restack needed");
+ expect(signal.tone).toBe("warning");
+ });
+
+ it("escalates over a softer size / sensitive-path note", () => {
+ // Critical findings outrank the size note (which would otherwise win).
+ const signal = cardSignal(
+ makeReview({
+ gate_state: "InReview",
+ diff: { raw: LARGE },
+ review_findings: [CRITICAL],
+ }),
+ );
+ expect(signal.tone).toBe("danger");
+ expect(signal.reason).toBe("Needs your review · Agent flagged 1 critical");
+ });
+
+ it("does not escalate non-actionable states", () => {
+ const dispatched = cardSignal(
+ makeReview({ gate_state: "Dispatched", review_findings: [CRITICAL] }),
+ );
+ const approved = cardSignal(
+ makeReview({ gate_state: "Approved", review_findings: [CRITICAL] }),
+ );
+ expect(dispatched.tone).not.toBe("danger");
+ expect(approved.tone).not.toBe("danger");
+ });
+});
diff --git a/app/src/lib/card-signal.ts b/app/src/lib/card-signal.ts
index 7f80ed9..a639b55 100644
--- a/app/src/lib/card-signal.ts
+++ b/app/src/lib/card-signal.ts
@@ -12,6 +12,8 @@ import type { Review } from "../bindings/Review";
import type { GateState } from "../bindings/GateState";
import { elapsedSince } from "./relative-time";
import { attentionReasons } from "./attention";
+import { ciState } from "./ci";
+import { findingCounts } from "./finding-severity";
function assertNever(x: never): never {
throw new Error(`unreachable: ${String(x)}`);
@@ -22,6 +24,7 @@ export type SignalTone =
| "attention"
| "running"
| "warning"
+ | "danger"
| "done"
| "neutral";
@@ -40,13 +43,38 @@ export interface CardSignal {
}
/**
- * Attach the sharpest risk note to an actionable review's signal, keeping the
- * gate reason as the loud headline. Precedence follows {@link attentionReasons}
- * (CI failing, then size, then sensitive paths); `undefined` when the review is
- * clean, so `note` is omitted rather than set empty.
+ * Layer the sharpest attention signal onto an actionable review's reason line.
+ *
+ * Priority below `stale` (which preempts the whole line, handled in
+ * {@link cardSignal}):
+ *
+ * CI failing > agent-flagged critical findings > large diff > sensitive paths
+ *
+ * A broken build is the harder blocker, so a CI-failing review keeps its normal
+ * "needs review" headline with a muted `· CI failing` note (per
+ * {@link attentionReasons}, which orders CI first). A critical-findings
+ * escalation slots directly *below* CI failing and *above* the softer size /
+ * sensitive-path notes: when there is no CI failure and the pre-review agent
+ * flagged ≥1 Critical finding, the whole reason line folds to danger tone —
+ * `Needs your review · Agent flagged N critical` — so the reviewer sees red. The
+ * critical count is folded into `reason` (not a muted `note`) precisely so the
+ * escalation reads red end-to-end. Warning-only findings never escalate the line
+ * (they surface as chips only); they leave the muted size/sensitive note intact.
*/
-function withRiskNote(signal: CardSignal, review: Review): CardSignal {
- const note = attentionReasons(review)[0];
+function withAttentionSignal(signal: CardSignal, review: Review): CardSignal {
+ const reasons = attentionReasons(review);
+ const ciFailing =
+ review.ci_summary !== null && ciState(review.ci_summary) === "fail";
+ const critical = findingCounts(review.review_findings).critical;
+
+ if (!ciFailing && critical > 0) {
+ return {
+ reason: `${signal.reason} · Agent flagged ${String(critical)} critical`,
+ tone: "danger",
+ };
+ }
+
+ const note = reasons[0];
return note === undefined ? signal : { ...signal, note };
}
@@ -64,17 +92,17 @@ export function cardSignal(review: Review, now: number = Date.now()): CardSignal
const state: GateState = review.gate_state;
switch (state) {
case "Pending":
- return withRiskNote(
+ return withAttentionSignal(
{ reason: "Needs your review", tone: "attention" },
review,
);
case "InReview":
- return withRiskNote(
+ return withAttentionSignal(
{ reason: "Needs your review", tone: "attention" },
review,
);
case "Reworked":
- return withRiskNote(
+ return withAttentionSignal(
{ reason: "Agent reworked — re-review", tone: "attention" },
review,
);
diff --git a/app/src/lib/finding-severity.test.ts b/app/src/lib/finding-severity.test.ts
index d8010ea..5e03b40 100644
--- a/app/src/lib/finding-severity.test.ts
+++ b/app/src/lib/finding-severity.test.ts
@@ -3,6 +3,7 @@ import {
severityRank,
sortFindingsBySeverity,
severityMeta,
+ findingCounts,
} from "./finding-severity";
import { makeFinding } from "../test/fixtures";
@@ -49,3 +50,35 @@ describe("severityMeta", () => {
expect(severityMeta("Info").dot).toBe("bg-muted-foreground");
});
});
+
+describe("findingCounts", () => {
+ it("returns all-zero for no findings", () => {
+ expect(findingCounts([])).toEqual({ critical: 0, warning: 0, info: 0 });
+ });
+
+ it("counts findings per severity class", () => {
+ const findings = [
+ makeFinding({ id: "c1", severity: "Critical" }),
+ makeFinding({ id: "c2", severity: "Critical" }),
+ makeFinding({ id: "w1", severity: "Warning" }),
+ makeFinding({ id: "i1", severity: "Info" }),
+ makeFinding({ id: "i2", severity: "Info" }),
+ makeFinding({ id: "i3", severity: "Info" }),
+ ];
+ expect(findingCounts(findings)).toEqual({
+ critical: 2,
+ warning: 1,
+ info: 3,
+ });
+ });
+
+ it("does not filter dismissed ids (it is dismissal-agnostic)", () => {
+ // Unlike FindingsPanel's findingsBreakdown, this counts every finding — the
+ // strip and cards read straight from review.review_findings.
+ const findings = [
+ makeFinding({ id: "a", severity: "Warning" }),
+ makeFinding({ id: "b", severity: "Warning" }),
+ ];
+ expect(findingCounts(findings).warning).toBe(2);
+ });
+});
diff --git a/app/src/lib/finding-severity.ts b/app/src/lib/finding-severity.ts
index daf1092..1bee524 100644
--- a/app/src/lib/finding-severity.ts
+++ b/app/src/lib/finding-severity.ts
@@ -44,6 +44,44 @@ export function sortFindingsBySeverity(
.sort((a, b) => severityRank(b.severity) - severityRank(a.severity));
}
+/** Per-severity counts of a set of findings. */
+export interface FindingCounts {
+ readonly critical: number;
+ readonly warning: number;
+ readonly info: number;
+}
+
+/**
+ * Count findings per severity class. Pure and dismissal-agnostic: the diff-tab
+ * agent strip and the board cards read straight from `review.review_findings`
+ * with no dismissal concept, so — unlike `FindingsPanel`'s `findingsBreakdown`,
+ * which filters a dismissed set — this takes only the findings. Shared so the
+ * strip, the cards, and (later) the board preview rail count identically.
+ */
+export function findingCounts(
+ findings: readonly ReviewFinding[],
+): FindingCounts {
+ let critical = 0;
+ let warning = 0;
+ let info = 0;
+ for (const f of findings) {
+ switch (f.severity) {
+ case "Critical":
+ critical += 1;
+ break;
+ case "Warning":
+ warning += 1;
+ break;
+ case "Info":
+ info += 1;
+ break;
+ default:
+ return assertNever(f.severity);
+ }
+ }
+ return { critical, warning, info };
+}
+
/** Presentation for a finding severity: short label, dot, and text color. */
export interface SeverityMeta {
/** Short uppercase label used in dense chips (`CRIT` / `WARN` / `INFO`). */