diff --git a/app/(chat)/findings/__tests__/page.test.tsx b/app/(chat)/findings/__tests__/page.test.tsx
new file mode 100644
index 000000000..c25deea1a
--- /dev/null
+++ b/app/(chat)/findings/__tests__/page.test.tsx
@@ -0,0 +1,130 @@
+import "@testing-library/jest-dom";
+import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+
+const mockUsePaginatedQuery = jest.fn();
+const mockUseQuery = jest.fn((_ref: unknown, args: any) =>
+  args?.findingId ? mockFinding : mockSourceChats,
+);
+const mockCapture = jest.fn();
+let mockMobile = false;
+
+jest.mock("convex/react", () => ({
+  useConvexAuth: () => ({ isLoading: false, isAuthenticated: true }),
+  usePaginatedQuery: (...args: unknown[]) => mockUsePaginatedQuery(...args),
+  useQuery: (...args: unknown[]) => mockUseQuery(...args),
+  useMutation: () => jest.fn(),
+}));
+
+jest.mock("@/app/contexts/GlobalState", () => ({
+  useGlobalState: () => ({
+    setChatSidebarOpen: jest.fn(),
+    closeSidebar: jest.fn(),
+  }),
+}));
+
+jest.mock("@/hooks/use-mobile", () => ({
+  useIsMobile: () => mockMobile,
+}));
+
+jest.mock("@/app/hooks/useTauri", () => ({ navigateToAuth: jest.fn() }));
+jest.mock("@/lib/analytics/client", () => ({
+  captureAuthenticatedEvent: mockCapture,
+}));
+
+const mockFinding = {
+  finding_id: "finding-1",
+  title: "Confirmed IDOR",
+  target: "https://app.example.test",
+  endpoint: "/api/invoices/other",
+  method: "GET",
+  severity: "high",
+  cvss_score: 7.1,
+  chat_id: "chat-1",
+  chat_title: "Invoice test",
+  created_at: Date.now(),
+  updated_at: Date.now(),
+  message_id: "message-1",
+  description: "Another account's invoice is readable.",
+  impact: "Billing data disclosure.",
+  technical_analysis: "Missing owner predicate.",
+  poc_description: "Request another account's invoice.",
+  poc_script_code: "curl /api/invoices/other",
+  remediation_steps: "Add an owner predicate.",
+  evidence: "HTTP 200 returned another account's data.",
+  assumptions: "Ordinary account.",
+  fix_effort: "low",
+  cvss_vector: "CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N",
+  cvss_breakdown: {
+    attack_vector: "N",
+    attack_complexity: "L",
+    privileges_required: "L",
+    user_interaction: "N",
+    scope: "U",
+    confidentiality: "H",
+    integrity: "N",
+    availability: "N",
+  },
+};
+
+const mockSourceChats = [{ chat_id: "chat-1", chat_title: "Invoice test" }];
+
+const Page = require("../page").default as typeof import("../page").default;
+
+describe("FindingsPage", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockMobile = false;
+    mockUsePaginatedQuery.mockReturnValue({
+      results: [mockFinding],
+      status: "Exhausted",
+      loadMore: jest.fn(),
+    });
+  });
+
+  it("lists metadata, searches, and exposes severity/source filters", async () => {
+    render(<Page />);
+    expect(screen.getByRole("heading", { name: "Findings" })).toBeVisible();
+    expect(screen.getByText("Confirmed IDOR")).toBeVisible();
+    expect(screen.getByText("/api/invoices/other")).toBeVisible();
+    expect(screen.getByText("Invoice test")).toBeVisible();
+    expect(screen.getByText("CVSS 7.1")).toBeVisible();
+    expect(screen.getByLabelText("Filter by severity")).toBeVisible();
+    expect(screen.getByLabelText("Filter by source chat")).toBeVisible();
+
+    fireEvent.change(screen.getByLabelText("Search findings"), {
+      target: { value: "CWE-639" },
+    });
+    await waitFor(() => {
+      expect(mockUsePaginatedQuery).toHaveBeenLastCalledWith(
+        expect.anything(),
+        expect.objectContaining({ search: "CWE-639" }),
+        { initialNumItems: 25 },
+      );
+    });
+    expect(mockCapture).toHaveBeenCalledWith("findings_page_viewed");
+  });
+
+  it("opens the reusable detail alongside the desktop list", () => {
+    render(<Page />);
+    fireEvent.click(screen.getByText("Confirmed IDOR"));
+    expect(screen.getByText(mockFinding.description)).toBeVisible();
+    expect(screen.getByRole("link", { name: /Invoice test/i })).toHaveAttribute(
+      "href",
+      "/c/chat-1",
+    );
+    expect(mockCapture).toHaveBeenCalledWith("finding_viewed", {
+      surface: "findings_page",
+    });
+  });
+
+  it("uses a full-screen mobile detail with a back control", () => {
+    mockMobile = true;
+    render(<Page />);
+    fireEvent.click(screen.getByText("Confirmed IDOR"));
+    expect(
+      screen.getByRole("button", { name: "Back to findings" }),
+    ).toBeVisible();
+    expect(screen.getByText(mockFinding.description)).toBeVisible();
+  });
+});
diff --git a/app/(chat)/findings/page.tsx b/app/(chat)/findings/page.tsx
new file mode 100644
index 000000000..98eba1194
--- /dev/null
+++ b/app/(chat)/findings/page.tsx
@@ -0,0 +1,284 @@
+"use client";
+
+import { useDeferredValue, useEffect, useState } from "react";
+import { useConvexAuth, usePaginatedQuery, useQuery } from "convex/react";
+import { formatDistanceToNow } from "date-fns";
+import { ArrowLeft, PanelLeft, Search, ShieldAlert } from "lucide-react";
+import { api } from "@/convex/_generated/api";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { FindingDetail } from "@/app/components/findings/FindingDetail";
+import { getFindingSeverityClasses } from "@/app/components/findings/FindingCard";
+import { useGlobalState } from "@/app/contexts/GlobalState";
+import { useIsMobile } from "@/hooks/use-mobile";
+import { navigateToAuth } from "@/app/hooks/useTauri";
+import { captureAuthenticatedEvent } from "@/lib/analytics/client";
+import { cn } from "@/lib/utils";
+import type {
+  FindingSeverity,
+  FindingSourceChat,
+  FindingSummary,
+} from "@/types/finding";
+
+const SEVERITIES: FindingSeverity[] = [
+  "critical",
+  "high",
+  "medium",
+  "low",
+  "info",
+];
+
+export default function FindingsPage() {
+  const { isLoading, isAuthenticated } = useConvexAuth();
+  const { setChatSidebarOpen, closeSidebar } = useGlobalState();
+  const isMobile = useIsMobile();
+  const [search, setSearch] = useState("");
+  const deferredSearch = useDeferredValue(search.trim());
+  const [severity, setSeverity] = useState<"all" | FindingSeverity>("all");
+  const [chatId, setChatId] = useState("all");
+  const [selectedFindingId, setSelectedFindingId] = useState<string | null>(
+    null,
+  );
+
+  useEffect(() => {
+    if (!isLoading && !isAuthenticated) navigateToAuth("/login");
+  }, [isAuthenticated, isLoading]);
+
+  useEffect(() => {
+    if (!isAuthenticated) return;
+    captureAuthenticatedEvent("findings_page_viewed");
+  }, [isAuthenticated]);
+
+  const findingsQuery = usePaginatedQuery(
+    api.findings.listFindings,
+    isAuthenticated
+      ? {
+          ...(deferredSearch ? { search: deferredSearch } : {}),
+          ...(severity !== "all" ? { severity } : {}),
+          ...(chatId !== "all" ? { chatId } : {}),
+        }
+      : "skip",
+    { initialNumItems: 25 },
+  );
+  const sourceChats = useQuery(
+    api.findings.getFindingSourceChats,
+    isAuthenticated ? {} : "skip",
+  ) as FindingSourceChat[] | undefined;
+  const findings = (findingsQuery.results ?? []) as FindingSummary[];
+
+  const selectFinding = (findingId: string) => {
+    setSelectedFindingId(findingId);
+    closeSidebar();
+    captureAuthenticatedEvent("finding_viewed", { surface: "findings_page" });
+  };
+
+  if (isLoading || !isAuthenticated) {
+    return (
+      <div className="flex h-full items-center justify-center text-sm text-muted-foreground">
+        Loading findings…
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex h-full min-h-0 bg-background">
+      <main
+        className={cn(
+          "flex min-w-0 flex-1 flex-col",
+          selectedFindingId && isMobile === false && "border-r border-border",
+        )}
+      >
+        <header className="flex shrink-0 items-center gap-3 border-b border-border px-4 py-3 sm:px-6">
+          <Button
+            variant="ghost"
+            size="icon"
+            onClick={() => setChatSidebarOpen(true)}
+            aria-label="Open navigation"
+          >
+            <PanelLeft className="size-5" />
+          </Button>
+          <div className="min-w-0 flex-1">
+            <h1 className="text-lg font-semibold text-foreground">Findings</h1>
+            <p className="hidden text-xs text-muted-foreground sm:block">
+              Confirmed vulnerabilities saved by Agent
+            </p>
+          </div>
+        </header>
+
+        <div className="flex min-h-0 flex-1 flex-col">
+          <div className="grid shrink-0 gap-2 border-b border-border p-4 sm:grid-cols-[minmax(220px,1fr)_160px_220px] sm:px-6">
+            <div className="relative">
+              <Search className="pointer-events-none absolute left-3 top-1/2 size-4 -translate-y-1/2 text-muted-foreground" />
+              <Input
+                value={search}
+                onChange={(event) => setSearch(event.target.value)}
+                placeholder="Search title, target, endpoint, CVE, or CWE"
+                className="pl-9"
+                aria-label="Search findings"
+              />
+            </div>
+            <Select
+              value={severity}
+              onValueChange={(value) =>
+                setSeverity(value as "all" | FindingSeverity)
+              }
+            >
+              <SelectTrigger aria-label="Filter by severity">
+                <SelectValue placeholder="All severities" />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem value="all">All severities</SelectItem>
+                {SEVERITIES.map((value) => (
+                  <SelectItem key={value} value={value}>
+                    {value[0].toUpperCase() + value.slice(1)}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+            <Select value={chatId} onValueChange={setChatId}>
+              <SelectTrigger aria-label="Filter by source chat">
+                <SelectValue placeholder="All source chats" />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem value="all">All source chats</SelectItem>
+                {(sourceChats ?? []).map((chat) => (
+                  <SelectItem key={chat.chat_id} value={chat.chat_id}>
+                    {chat.chat_title}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+
+          <div className="min-h-0 flex-1 overflow-y-auto">
+            {findingsQuery.status === "LoadingFirstPage" ? (
+              <div className="flex h-48 items-center justify-center text-sm text-muted-foreground">
+                Loading findings…
+              </div>
+            ) : findings.length === 0 ? (
+              <div className="flex h-full min-h-64 flex-col items-center justify-center gap-3 p-8 text-center">
+                <div className="flex size-12 items-center justify-center rounded-xl border border-border bg-muted/30">
+                  <ShieldAlert className="size-6 text-muted-foreground" />
+                </div>
+                <div>
+                  <p className="font-medium text-foreground">
+                    No findings found
+                  </p>
+                  <p className="mt-1 max-w-sm text-sm text-muted-foreground">
+                    Agent saves a finding only after it has concrete evidence,
+                    reliable reproduction, and a working PoC.
+                  </p>
+                </div>
+              </div>
+            ) : (
+              <div className="divide-y divide-border">
+                {findings.map((finding) => (
+                  <button
+                    type="button"
+                    key={finding.finding_id}
+                    onClick={() => selectFinding(finding.finding_id)}
+                    className={cn(
+                      "grid w-full gap-2 px-4 py-4 text-left transition-colors hover:bg-muted/30 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring sm:grid-cols-[100px_minmax(180px,1.5fr)_minmax(160px,1fr)_minmax(130px,0.8fr)_100px] sm:items-center sm:px-6",
+                      selectedFindingId === finding.finding_id && "bg-muted/40",
+                    )}
+                  >
+                    <div className="flex items-center gap-2 sm:block">
+                      <span
+                        className={cn(
+                          "inline-flex rounded-md border px-2 py-1 text-[11px] font-semibold uppercase",
+                          getFindingSeverityClasses(finding.severity),
+                        )}
+                      >
+                        {finding.severity}
+                      </span>
+                      <span className="font-mono text-xs text-muted-foreground sm:mt-1 sm:block">
+                        CVSS {finding.cvss_score.toFixed(1)}
+                      </span>
+                    </div>
+                    <div className="min-w-0">
+                      <div className="truncate text-sm font-medium text-foreground">
+                        {finding.title}
+                      </div>
+                    </div>
+                    <div className="min-w-0 font-mono text-xs text-muted-foreground">
+                      <div className="truncate">{finding.target}</div>
+                      {finding.endpoint && (
+                        <div className="mt-0.5 truncate">
+                          {finding.endpoint}
+                        </div>
+                      )}
+                    </div>
+                    <div className="truncate text-xs text-muted-foreground">
+                      {finding.chat_title}
+                    </div>
+                    <div className="text-xs text-muted-foreground sm:text-right">
+                      {formatDistanceToNow(new Date(finding.created_at), {
+                        addSuffix: true,
+                      })}
+                    </div>
+                  </button>
+                ))}
+              </div>
+            )}
+
+            {findingsQuery.status === "CanLoadMore" && (
+              <div className="flex justify-center p-4">
+                <Button
+                  variant="outline"
+                  onClick={() => findingsQuery.loadMore(25)}
+                >
+                  Load more
+                </Button>
+              </div>
+            )}
+            {findingsQuery.status === "LoadingMore" && (
+              <div className="p-4 text-center text-sm text-muted-foreground">
+                Loading more…
+              </div>
+            )}
+          </div>
+        </div>
+      </main>
+
+      {selectedFindingId && isMobile === false && (
+        <aside className="h-full min-w-0 flex-[1.15] bg-background">
+          <FindingDetail
+            findingId={selectedFindingId}
+            surface="findings_page"
+            onDeleted={() => setSelectedFindingId(null)}
+          />
+        </aside>
+      )}
+
+      {selectedFindingId && isMobile && (
+        <div className="fixed inset-0 z-50 flex flex-col bg-background">
+          <div className="flex h-14 shrink-0 items-center gap-2 border-b border-border px-3">
+            <Button
+              variant="ghost"
+              size="icon"
+              onClick={() => setSelectedFindingId(null)}
+              aria-label="Back to findings"
+            >
+              <ArrowLeft className="size-5" />
+            </Button>
+            <span className="font-medium text-foreground">Finding</span>
+          </div>
+          <div className="min-h-0 flex-1">
+            <FindingDetail
+              findingId={selectedFindingId}
+              surface="findings_page"
+              onDeleted={() => setSelectedFindingId(null)}
+            />
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/app/components/ComputerSidebar.tsx b/app/components/ComputerSidebar.tsx
index 6b14bd27c..9e912b8ea 100644
--- a/app/components/ComputerSidebar.tsx
+++ b/app/components/ComputerSidebar.tsx
@@ -31,11 +31,13 @@ import {
   isSidebarProxy,
   isSidebarWebSearch,
   isSidebarNotes,
+  isSidebarFinding,
   isSidebarSharedFiles,
   type SidebarContent,
   type ChatStatus,
   type NoteCategory,
 } from "@/types/chat";
+import { FindingDetail } from "./findings/FindingDetail";
 import type { Id } from "@/convex/_generated/dataModel";
 import type { FilePart } from "@/types/file";
 import { FilePartRenderer } from "./FilePartRenderer";
@@ -439,6 +441,7 @@ export const ComputerSidebarBase: React.FC<ComputerSidebarProps> = ({
   const isProxy = isSidebarProxy(sidebarContent);
   const isWebSearch = isSidebarWebSearch(sidebarContent);
   const isNotes = isSidebarNotes(sidebarContent);
+  const isFinding = isSidebarFinding(sidebarContent);
   const isSharedFiles = isSidebarSharedFiles(sidebarContent);
 
   // Use resolved versions for display metadata so streaming updates are reflected
@@ -452,9 +455,11 @@ export const ComputerSidebarBase: React.FC<ComputerSidebarProps> = ({
   const icon = getSidebarIcon(displayContent);
   const toolName = getToolName(displayContent);
   const displayTarget = getDisplayTarget(displayContent);
-  const headerTitle = isProxy
-    ? "HackerAI\u2019s Proxy"
-    : "HackerAI\u2019s Computer";
+  const headerTitle = isFinding
+    ? "Finding"
+    : isProxy
+      ? "HackerAI\u2019s Proxy"
+      : "HackerAI\u2019s Computer";
 
   const handleClose = () => {
     closeSidebar();
@@ -542,6 +547,10 @@ export const ComputerSidebarBase: React.FC<ComputerSidebarProps> = ({
                     <div className="max-w-[250px] truncate text-muted-foreground text-sm font-medium">
                       Notes
                     </div>
+                  ) : isFinding ? (
+                    <div className="max-w-[250px] truncate text-muted-foreground text-sm font-medium">
+                      Vulnerability report
+                    </div>
                   ) : isSharedFiles ? (
                     <div className="max-w-[250px] truncate text-muted-foreground text-sm font-medium">
                       Shared Files
@@ -558,7 +567,7 @@ export const ComputerSidebarBase: React.FC<ComputerSidebarProps> = ({
                 </div>
 
                 {/* Action buttons - far right */}
-                {!isWebSearch && !isNotes && !isSharedFiles && (
+                {!isWebSearch && !isNotes && !isFinding && !isSharedFiles && (
                   <CodeActionButtons
                     content={
                       isFile && resolvedFile
@@ -750,8 +759,7 @@ export const ComputerSidebarBase: React.FC<ComputerSidebarProps> = ({
                                   key={file.fileId || `file-${index}`}
                                   part={{
                                     fileId: file.fileId as
-                                      | Id<"files">
-                                      | undefined,
+                                      Id<"files"> | undefined,
                                     s3Key: file.s3Key,
                                     name: file.name,
                                     filename: file.name,
@@ -766,6 +774,13 @@ export const ComputerSidebarBase: React.FC<ComputerSidebarProps> = ({
                           </div>
                         </div>
                       )}
+                      {isFinding && (
+                        <FindingDetail
+                          findingId={sidebarContent.findingId}
+                          surface="computer_sidebar"
+                          className="font-sans"
+                        />
+                      )}
                       {isNotes && (
                         <div className="flex-1 min-h-0 h-full overflow-y-auto">
                           <div className="flex flex-col px-4 py-3">
diff --git a/app/components/MessagePartHandler.tsx b/app/components/MessagePartHandler.tsx
index 129eb03cf..c445b4b88 100644
--- a/app/components/MessagePartHandler.tsx
+++ b/app/components/MessagePartHandler.tsx
@@ -8,6 +8,8 @@ import { HttpRequestToolHandler } from "./tools/HttpRequestToolHandler";
 import { WebToolHandler } from "./tools/WebToolHandler";
 import { TodoToolHandler } from "./tools/TodoToolHandler";
 import { NotesToolHandler } from "./tools/NotesToolHandler";
+import { FindingToolHandler } from "./tools/FindingToolHandler";
+import { FindingCard } from "./findings/FindingCard";
 import { ProxyToolHandler } from "./tools/ProxyToolHandler";
 import { GetTerminalFilesHandler } from "./tools/GetTerminalFilesHandler";
 import { SummarizationHandler } from "./tools/SummarizationHandler";
@@ -257,6 +259,19 @@ export const MessagePartHandler = memo(function MessagePartHandler({
         <NotesToolHandler part={part} status={status} toolName="delete_note" />
       );
 
+    case "tool-create_vulnerability_report":
+      return <FindingToolHandler part={part} status={status} />;
+
+    case "data-shared-finding":
+      return part.data ? (
+        <FindingCard
+          title={part.data.title}
+          target={part.data.target}
+          severity={part.data.severity}
+          cvssScore={part.data.cvss_score}
+        />
+      ) : null;
+
     case "tool-list_requests":
       return (
         <ProxyToolHandler
diff --git a/app/components/SidebarHeader.tsx b/app/components/SidebarHeader.tsx
index 8e2c65c6c..df7e43741 100644
--- a/app/components/SidebarHeader.tsx
+++ b/app/components/SidebarHeader.tsx
@@ -1,13 +1,14 @@
 "use client";
 
 import { useState, useEffect, useMemo, FC } from "react";
-import { useRouter } from "next/navigation";
+import { usePathname, useRouter } from "next/navigation";
 import { Button } from "@/components/ui/button";
 import {
   PanelLeft,
   Sidebar as SidebarIcon,
   SquarePen,
   Search,
+  ShieldAlert,
 } from "lucide-react";
 import { useSidebar } from "@/components/ui/sidebar";
 import { HackerAISVG } from "@/components/icons/hackerai-svg";
@@ -39,6 +40,7 @@ const SidebarHeaderContentImpl: FC<SidebarHeaderContentImplProps> = ({
 }) => {
   const isMobile = useIsMobile();
   const router = useRouter();
+  const pathname = usePathname();
   const {
     setChatSidebarOpen,
     closeSidebar,
@@ -101,6 +103,12 @@ const SidebarHeaderContentImpl: FC<SidebarHeaderContentImplProps> = ({
     setIsSearchOpen(true);
   };
 
+  const handleFindingsOpen = () => {
+    closeSidebar();
+    if (isMobile) setChatSidebarOpen(false);
+    router.push("/findings");
+  };
+
   const handleSearchClose = () => {
     setIsSearchOpen(false);
   };
@@ -162,6 +170,20 @@ const SidebarHeaderContentImpl: FC<SidebarHeaderContentImplProps> = ({
                 <Search className="w-4 h-4" />
               </Button>
             </div>
+
+            <div className="p-1">
+              <Button
+                variant="ghost"
+                size="sm"
+                className={`h-8 w-8 p-0 hover:bg-sidebar-accent/50 ${
+                  pathname === "/findings" ? "bg-sidebar-accent" : ""
+                }`}
+                onClick={handleFindingsOpen}
+                aria-label="Open findings"
+              >
+                <ShieldAlert className="w-4 h-4" />
+              </Button>
+            </div>
           </div>
         </div>
 
@@ -232,6 +254,22 @@ const SidebarHeaderContentImpl: FC<SidebarHeaderContentImplProps> = ({
             </div>
           </Button>
         </div>
+
+        <div className="px-2 py-1">
+          <Button
+            variant="ghost"
+            className={`relative flex w-full justify-start items-center rounded-lg p-2 h-auto hover:bg-sidebar-accent/50 text-left ${
+              pathname === "/findings" ? "bg-sidebar-accent" : ""
+            }`}
+            onClick={handleFindingsOpen}
+            aria-label="Open findings"
+          >
+            <ShieldAlert className="w-4 h-4" />
+            <div className="mr-2 flex-1 overflow-hidden text-clip whitespace-nowrap text-sm font-medium text-left">
+              Findings
+            </div>
+          </Button>
+        </div>
       </div>
 
       {/* Search Dialog */}
diff --git a/app/components/computer-sidebar-utils.tsx b/app/components/computer-sidebar-utils.tsx
index 36d9efa1a..400295374 100644
--- a/app/components/computer-sidebar-utils.tsx
+++ b/app/components/computer-sidebar-utils.tsx
@@ -7,6 +7,7 @@ import {
   Search,
   FolderSearch,
   StickyNote,
+  ShieldAlert,
   FileDown,
   Radar,
 } from "lucide-react";
@@ -16,6 +17,7 @@ import {
   isSidebarProxy,
   isSidebarWebSearch,
   isSidebarNotes,
+  isSidebarFinding,
   isSidebarSharedFiles,
   type SidebarContent,
   type NoteCategory,
@@ -163,6 +165,8 @@ export function getActionText(content: SidebarContent): string {
     return completedActionMap[content.action];
   }
 
+  if (isSidebarFinding(content)) return "Saved finding";
+
   if (isSidebarSharedFiles(content)) {
     if (content.isExecuting) {
       const ready = content.files.length;
@@ -198,6 +202,7 @@ export function getSidebarIcon(content: SidebarContent): React.ReactNode {
   if (isSidebarTerminal(content)) return <Terminal className={iconClass} />;
   if (isSidebarWebSearch(content)) return <Search className={iconClass} />;
   if (isSidebarNotes(content)) return <StickyNote className={iconClass} />;
+  if (isSidebarFinding(content)) return <ShieldAlert className={iconClass} />;
   if (isSidebarSharedFiles(content)) return <FileDown className={iconClass} />;
   return <Edit className={iconClass} />;
 }
@@ -215,6 +220,7 @@ export function getToolName(content: SidebarContent): string {
   }
   if (isSidebarWebSearch(content)) return "Search";
   if (isSidebarNotes(content)) return "Notes";
+  if (isSidebarFinding(content)) return "Findings";
   if (isSidebarSharedFiles(content)) return "Downloads";
   return "Tool";
 }
@@ -244,6 +250,7 @@ export function getDisplayTarget(content: SidebarContent): string {
     }
     return content.affectedTitle || "";
   }
+  if (isSidebarFinding(content)) return content.title;
   if (isSidebarSharedFiles(content)) {
     const names = content.files.length
       ? content.files.map((f) => f.name)
diff --git a/app/components/findings/FindingCard.tsx b/app/components/findings/FindingCard.tsx
new file mode 100644
index 000000000..95482ecb1
--- /dev/null
+++ b/app/components/findings/FindingCard.tsx
@@ -0,0 +1,81 @@
+"use client";
+
+import { ShieldAlert } from "lucide-react";
+import { cn } from "@/lib/utils";
+import type { FindingSeverity } from "@/types/finding";
+
+const severityClasses: Record<FindingSeverity, string> = {
+  critical: "border-red-500/30 bg-red-500/10 text-red-500",
+  high: "border-orange-500/30 bg-orange-500/10 text-orange-500",
+  medium: "border-yellow-500/30 bg-yellow-500/10 text-yellow-500",
+  low: "border-blue-500/30 bg-blue-500/10 text-blue-500",
+  info: "border-slate-500/30 bg-slate-500/10 text-slate-500",
+};
+
+export const getFindingSeverityClasses = (severity: FindingSeverity) =>
+  severityClasses[severity];
+
+export function FindingCard({
+  title,
+  target,
+  severity,
+  cvssScore,
+  onClick,
+  className,
+}: {
+  title: string;
+  target: string;
+  severity: FindingSeverity;
+  cvssScore: number;
+  onClick?: () => void;
+  className?: string;
+}) {
+  const content = (
+    <>
+      <div
+        className={cn(
+          "flex size-9 shrink-0 items-center justify-center rounded-lg border",
+          severityClasses[severity],
+        )}
+      >
+        <ShieldAlert className="size-4" aria-hidden="true" />
+      </div>
+      <div className="min-w-0 flex-1 text-left">
+        <div className="truncate text-sm font-medium text-foreground">
+          {title}
+        </div>
+        <div className="mt-0.5 truncate font-mono text-xs text-muted-foreground">
+          {target}
+        </div>
+      </div>
+      <div
+        className={cn(
+          "shrink-0 rounded-md border px-2 py-1 text-[11px] font-semibold uppercase",
+          severityClasses[severity],
+        )}
+      >
+        {severity} · {cvssScore.toFixed(1)}
+      </div>
+    </>
+  );
+
+  const classes = cn(
+    "flex w-full max-w-xl items-center gap-3 rounded-xl border border-border bg-muted/20 p-3",
+    onClick &&
+      "cursor-pointer transition-colors hover:bg-muted/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+    className,
+  );
+
+  return onClick ? (
+    <button
+      type="button"
+      className={classes}
+      onClick={onClick}
+      aria-label={`Open finding: ${title}`}
+    >
+      {content}
+    </button>
+  ) : (
+    <div className={classes}>{content}</div>
+  );
+}
diff --git a/app/components/findings/FindingDetail.tsx b/app/components/findings/FindingDetail.tsx
new file mode 100644
index 000000000..eb0dcb118
--- /dev/null
+++ b/app/components/findings/FindingDetail.tsx
@@ -0,0 +1,268 @@
+"use client";
+
+import Link from "next/link";
+import { useMutation, useQuery } from "convex/react";
+import { api } from "@/convex/_generated/api";
+import { ExternalLink, ShieldAlert, Trash2 } from "lucide-react";
+import { useState } from "react";
+import { toast } from "sonner";
+import { Button } from "@/components/ui/button";
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+  AlertDialogTrigger,
+} from "@/components/ui/alert-dialog";
+import { MemoizedMarkdown } from "@/app/components/MemoizedMarkdown";
+import { captureAuthenticatedEvent } from "@/lib/analytics/client";
+import type { FindingDetailRecord } from "@/types/finding";
+import { cn } from "@/lib/utils";
+import { getFindingSeverityClasses } from "./FindingCard";
+
+const DetailSection = ({
+  title,
+  children,
+}: {
+  title: string;
+  children: React.ReactNode;
+}) => (
+  <section className="space-y-2">
+    <h3 className="text-xs font-semibold uppercase tracking-wide text-muted-foreground">
+      {title}
+    </h3>
+    <div className="text-sm text-foreground">{children}</div>
+  </section>
+);
+
+const MarkdownSection = ({
+  title,
+  value,
+}: {
+  title: string;
+  value: string;
+}) => (
+  <DetailSection title={title}>
+    <MemoizedMarkdown content={value} />
+  </DetailSection>
+);
+
+export function FindingDetail({
+  findingId,
+  finding: suppliedFinding,
+  onDeleted,
+  surface = "detail",
+  className,
+}: {
+  findingId?: string;
+  finding?: FindingDetailRecord | null;
+  onDeleted?: () => void;
+  surface?: "computer_sidebar" | "findings_page" | "detail";
+  className?: string;
+}) {
+  const queriedFinding = useQuery(
+    api.findings.getFinding,
+    suppliedFinding !== undefined || !findingId ? "skip" : { findingId },
+  ) as FindingDetailRecord | null | undefined;
+  const deleteFinding = useMutation(api.findings.deleteFinding);
+  const [isDeleting, setIsDeleting] = useState(false);
+  const finding =
+    suppliedFinding !== undefined ? suppliedFinding : queriedFinding;
+
+  if (finding === undefined) {
+    return (
+      <div className="flex h-full items-center justify-center p-8 text-sm text-muted-foreground">
+        Loading finding…
+      </div>
+    );
+  }
+
+  if (!finding) {
+    return (
+      <div className="flex h-full flex-col items-center justify-center gap-3 p-8 text-center">
+        <ShieldAlert className="size-8 text-muted-foreground" />
+        <div>
+          <p className="font-medium text-foreground">Finding deleted</p>
+          <p className="mt-1 text-sm text-muted-foreground">
+            This structured finding is no longer available.
+          </p>
+        </div>
+      </div>
+    );
+  }
+
+  const handleDelete = async () => {
+    setIsDeleting(true);
+    try {
+      const result = await deleteFinding({ findingId: finding.finding_id });
+      if (result.deleted) {
+        captureAuthenticatedEvent("finding_deleted", { surface });
+        toast.success("Finding deleted");
+        onDeleted?.();
+      }
+    } catch {
+      toast.error("Could not delete finding");
+    } finally {
+      setIsDeleting(false);
+    }
+  };
+
+  return (
+    <div className={cn("h-full overflow-y-auto", className)}>
+      <div className="mx-auto flex w-full max-w-3xl flex-col gap-6 p-4 sm:p-6">
+        <div className="space-y-3">
+          <div className="flex flex-wrap items-center gap-2">
+            <span
+              className={cn(
+                "rounded-md border px-2 py-1 text-xs font-semibold uppercase",
+                getFindingSeverityClasses(finding.severity),
+              )}
+            >
+              {finding.severity}
+            </span>
+            <span className="rounded-md border border-border bg-muted/30 px-2 py-1 font-mono text-xs text-foreground">
+              CVSS {finding.cvss_score.toFixed(1)}
+            </span>
+            {finding.cve && (
+              <span className="rounded-md border border-border px-2 py-1 font-mono text-xs text-muted-foreground">
+                {finding.cve}
+              </span>
+            )}
+            {finding.cwe && (
+              <span className="rounded-md border border-border px-2 py-1 font-mono text-xs text-muted-foreground">
+                {finding.cwe}
+              </span>
+            )}
+          </div>
+          <h2 className="text-xl font-semibold leading-tight text-foreground sm:text-2xl">
+            {finding.title}
+          </h2>
+          <div className="space-y-1 font-mono text-xs text-muted-foreground">
+            <div className="break-all">{finding.target}</div>
+            {finding.endpoint && (
+              <div className="break-all">
+                {finding.method ? `${finding.method} ` : ""}
+                {finding.endpoint}
+              </div>
+            )}
+          </div>
+          <div className="flex flex-wrap items-center justify-between gap-3 border-t border-border pt-3">
+            <Link
+              href={`/c/${finding.chat_id}`}
+              className="inline-flex items-center gap-1.5 text-sm text-muted-foreground hover:text-foreground"
+            >
+              {finding.chat_title}
+              <ExternalLink className="size-3.5" aria-hidden="true" />
+            </Link>
+            <AlertDialog>
+              <AlertDialogTrigger asChild>
+                <Button variant="outline" size="sm" disabled={isDeleting}>
+                  <Trash2 className="size-4" aria-hidden="true" />
+                  Delete
+                </Button>
+              </AlertDialogTrigger>
+              <AlertDialogContent>
+                <AlertDialogHeader>
+                  <AlertDialogTitle>Delete this finding?</AlertDialogTitle>
+                  <AlertDialogDescription>
+                    This permanently deletes the report and removes its card
+                    from the source assistant message.
+                  </AlertDialogDescription>
+                </AlertDialogHeader>
+                <AlertDialogFooter>
+                  <AlertDialogCancel>Cancel</AlertDialogCancel>
+                  <AlertDialogAction
+                    onClick={() => void handleDelete()}
+                    className="bg-destructive text-destructive-foreground hover:bg-destructive/90"
+                  >
+                    Delete finding
+                  </AlertDialogAction>
+                </AlertDialogFooter>
+              </AlertDialogContent>
+            </AlertDialog>
+          </div>
+        </div>
+
+        <MarkdownSection title="Description" value={finding.description} />
+        <MarkdownSection title="Impact" value={finding.impact} />
+        <MarkdownSection
+          title="Technical analysis"
+          value={finding.technical_analysis}
+        />
+        <MarkdownSection
+          title="Proof of concept"
+          value={finding.poc_description}
+        />
+        <DetailSection title="PoC script / payload">
+          <pre className="overflow-x-auto rounded-lg border border-border bg-muted/30 p-3 text-xs leading-relaxed">
+            <code>{finding.poc_script_code}</code>
+          </pre>
+        </DetailSection>
+        <MarkdownSection title="Evidence" value={finding.evidence} />
+        <MarkdownSection title="Assumptions" value={finding.assumptions} />
+        <MarkdownSection
+          title="Remediation"
+          value={finding.remediation_steps}
+        />
+
+        {finding.code_locations && finding.code_locations.length > 0 && (
+          <DetailSection title="Code locations">
+            <div className="space-y-3">
+              {finding.code_locations.map((location, index) => (
+                <div
+                  key={`${location.file}:${location.start_line}:${index}`}
+                  className="rounded-lg border border-border bg-muted/20 p-3"
+                >
+                  <div className="font-mono text-xs text-foreground">
+                    {location.file}:{location.start_line}-{location.end_line}
+                  </div>
+                  {location.label && (
+                    <div className="mt-1 text-xs text-muted-foreground">
+                      {location.label}
+                    </div>
+                  )}
+                  {location.snippet && (
+                    <pre className="mt-3 overflow-x-auto rounded-md bg-background p-3 text-xs">
+                      <code>{location.snippet}</code>
+                    </pre>
+                  )}
+                  {location.fix_before && location.fix_after && (
+                    <div className="mt-3 grid gap-3 lg:grid-cols-2">
+                      <div>
+                        <div className="mb-1 text-[11px] font-medium uppercase text-muted-foreground">
+                          Before
+                        </div>
+                        <pre className="overflow-x-auto rounded-md border border-red-500/20 bg-red-500/5 p-3 text-xs">
+                          <code>{location.fix_before}</code>
+                        </pre>
+                      </div>
+                      <div>
+                        <div className="mb-1 text-[11px] font-medium uppercase text-muted-foreground">
+                          After
+                        </div>
+                        <pre className="overflow-x-auto rounded-md border border-green-500/20 bg-green-500/5 p-3 text-xs">
+                          <code>{location.fix_after}</code>
+                        </pre>
+                      </div>
+                    </div>
+                  )}
+                </div>
+              ))}
+            </div>
+          </DetailSection>
+        )}
+
+        <DetailSection title="Scoring">
+          <div className="space-y-1 rounded-lg border border-border bg-muted/20 p-3 font-mono text-xs text-muted-foreground">
+            <div>{finding.cvss_vector}</div>
+            <div>Fix effort: {finding.fix_effort}</div>
+          </div>
+        </DetailSection>
+      </div>
+    </div>
+  );
+}
diff --git a/app/components/findings/__tests__/FindingCard.test.tsx b/app/components/findings/__tests__/FindingCard.test.tsx
new file mode 100644
index 000000000..c74eab76f
--- /dev/null
+++ b/app/components/findings/__tests__/FindingCard.test.tsx
@@ -0,0 +1,35 @@
+import "@testing-library/jest-dom";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { FindingCard } from "../FindingCard";
+
+describe("FindingCard", () => {
+  it("is non-clickable when rendered for a public share", () => {
+    render(
+      <FindingCard
+        title="Confirmed IDOR"
+        target="app.example.test"
+        severity="high"
+        cvssScore={7.1}
+      />,
+    );
+    expect(screen.getByText("Confirmed IDOR")).toBeVisible();
+    expect(screen.queryByRole("button")).not.toBeInTheDocument();
+  });
+
+  it("opens an authenticated finding when clickable", () => {
+    const onClick = jest.fn();
+    render(
+      <FindingCard
+        title="Confirmed IDOR"
+        target="app.example.test"
+        severity="high"
+        cvssScore={7.1}
+        onClick={onClick}
+      />,
+    );
+    fireEvent.click(
+      screen.getByRole("button", { name: "Open finding: Confirmed IDOR" }),
+    );
+    expect(onClick).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/app/components/findings/__tests__/FindingDetail.test.tsx b/app/components/findings/__tests__/FindingDetail.test.tsx
new file mode 100644
index 000000000..ebe5bf4fa
--- /dev/null
+++ b/app/components/findings/__tests__/FindingDetail.test.tsx
@@ -0,0 +1,112 @@
+import "@testing-library/jest-dom";
+import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { useMutation } from "convex/react";
+import type { FindingDetailRecord } from "@/types/finding";
+
+const mockCapture = jest.fn();
+jest.mock("@/lib/analytics/client", () => ({
+  captureAuthenticatedEvent: mockCapture,
+}));
+
+const { FindingDetail } =
+  require("../FindingDetail") as typeof import("../FindingDetail");
+
+const finding: FindingDetailRecord = {
+  finding_id: "finding-1",
+  title: "Confirmed IDOR",
+  target: "https://app.example.test",
+  endpoint: "/api/invoices/other",
+  method: "GET",
+  severity: "high",
+  cvss_score: 7.1,
+  chat_id: "chat-1",
+  chat_title: "Invoice test",
+  created_at: 1,
+  updated_at: 1,
+  message_id: "message-1",
+  description: "Another account's invoice is readable.",
+  impact: "Billing data disclosure.",
+  technical_analysis: "The handler omits an owner predicate.",
+  poc_description: "Request another account's invoice.",
+  poc_script_code: "curl /api/invoices/other",
+  remediation_steps: "Add an owner predicate.",
+  evidence: "HTTP 200 returned the other account's data.",
+  assumptions: "Ordinary authenticated account.",
+  fix_effort: "low",
+  cvss_vector: "CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N",
+  cvss_breakdown: {
+    attack_vector: "N",
+    attack_complexity: "L",
+    privileges_required: "L",
+    user_interaction: "N",
+    scope: "U",
+    confidentiality: "H",
+    integrity: "N",
+    availability: "N",
+  },
+  cwe: "CWE-639",
+  code_locations: [
+    {
+      file: "app/api/invoices/route.ts",
+      start_line: 20,
+      end_line: 22,
+      label: "Missing ownership predicate",
+      snippet: "findUnique({ id })",
+      fix_before: "where: { id }",
+      fix_after: "where: { id, userId }",
+    },
+  ],
+};
+
+describe("FindingDetail", () => {
+  beforeEach(() => jest.clearAllMocks());
+
+  it("renders the complete report and source chat link", () => {
+    render(<FindingDetail finding={finding} />);
+    expect(screen.getByRole("heading", { name: finding.title })).toBeVisible();
+    expect(screen.getByText("CWE-639")).toBeVisible();
+    expect(screen.getByText(finding.poc_script_code)).toBeVisible();
+    expect(screen.getByText(finding.evidence)).toBeVisible();
+    expect(screen.getByText("app/api/invoices/route.ts:20-22")).toBeVisible();
+    expect(screen.getByRole("link", { name: /Invoice test/i })).toHaveAttribute(
+      "href",
+      "/c/chat-1",
+    );
+  });
+
+  it("requires confirmation, deletes, and emits only surface analytics", async () => {
+    const mutation = useMutation({} as any) as jest.Mock;
+    mutation.mockResolvedValue({ deleted: true });
+    const onDeleted = jest.fn();
+    render(
+      <FindingDetail
+        finding={finding}
+        surface="findings_page"
+        onDeleted={onDeleted}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: "Delete" }));
+    expect(screen.getByText("Delete this finding?")).toBeVisible();
+    fireEvent.click(screen.getByRole("button", { name: "Delete finding" }));
+
+    await waitFor(() => {
+      expect(mutation).toHaveBeenCalledWith({ findingId: "finding-1" });
+      expect(onDeleted).toHaveBeenCalledTimes(1);
+    });
+    expect(mockCapture).toHaveBeenCalledWith("finding_deleted", {
+      surface: "findings_page",
+    });
+    expect(JSON.stringify(mockCapture.mock.calls)).not.toMatch(
+      /Confirmed IDOR|app\.example|HTTP 200|curl/,
+    );
+  });
+
+  it("renders loading and deleted states", () => {
+    const { rerender } = render(<FindingDetail finding={undefined as any} />);
+    expect(screen.getByText("Loading finding…")).toBeVisible();
+    rerender(<FindingDetail finding={null} />);
+    expect(screen.getByText("Finding deleted")).toBeVisible();
+  });
+});
diff --git a/app/components/tools/FindingToolHandler.tsx b/app/components/tools/FindingToolHandler.tsx
new file mode 100644
index 000000000..7a172176c
--- /dev/null
+++ b/app/components/tools/FindingToolHandler.tsx
@@ -0,0 +1,181 @@
+"use client";
+
+import { memo, useMemo } from "react";
+import { useQuery } from "convex/react";
+import { ShieldAlert } from "lucide-react";
+import { api } from "@/convex/_generated/api";
+import type { ChatStatus, SidebarFinding } from "@/types/chat";
+import type { FindingDetailRecord } from "@/types/finding";
+import { isSidebarFinding } from "@/types/chat";
+import ToolBlock from "@/components/ui/tool-block";
+import { useToolSidebar } from "@/app/hooks/useToolSidebar";
+import { captureAuthenticatedEvent } from "@/lib/analytics/client";
+import { FindingCard } from "@/app/components/findings/FindingCard";
+
+type FindingOutput = {
+  success?: boolean;
+  finding_id?: string;
+  title?: string;
+  target?: string;
+  endpoint?: string;
+  severity?: SidebarFinding["severity"];
+  cvss_score?: number;
+  error?: "validation" | "duplicate" | "chat_not_found" | "general";
+  message?: string;
+};
+
+const failureAction = (output: FindingOutput) => {
+  if (output.error === "duplicate") return "Duplicate finding rejected";
+  if (output.error === "validation") return "Finding validation failed";
+  return "Finding was not saved";
+};
+
+const SavedFindingCard = ({
+  output,
+  toolCallId,
+}: {
+  output: Required<
+    Pick<
+      FindingOutput,
+      "finding_id" | "title" | "target" | "severity" | "cvss_score"
+    >
+  > &
+    Pick<FindingOutput, "endpoint">;
+  toolCallId: string;
+}) => {
+  const finding = useQuery(api.findings.getFinding, {
+    findingId: output.finding_id,
+  }) as FindingDetailRecord | null | undefined;
+
+  const content = useMemo<SidebarFinding>(
+    () => ({
+      findingId: output.finding_id,
+      title: finding?.title ?? output.title,
+      target: finding?.target ?? output.target,
+      endpoint: finding?.endpoint ?? output.endpoint,
+      severity: finding?.severity ?? output.severity,
+      cvssScore: finding?.cvss_score ?? output.cvss_score,
+      isExecuting: false,
+      toolCallId,
+    }),
+    [finding, output, toolCallId],
+  );
+  const { handleOpenInSidebar } = useToolSidebar({
+    toolCallId,
+    content,
+    typeGuard: isSidebarFinding,
+  });
+
+  if (finding === null) {
+    return (
+      <ToolBlock
+        icon={<ShieldAlert aria-hidden="true" />}
+        action="Finding deleted"
+        target={output.title}
+      />
+    );
+  }
+
+  const handleOpen = () => {
+    captureAuthenticatedEvent("finding_viewed", { surface: "inline_card" });
+    handleOpenInSidebar();
+  };
+
+  return (
+    <FindingCard
+      title={content.title}
+      target={content.endpoint || content.target}
+      severity={content.severity}
+      cvssScore={content.cvssScore}
+      onClick={handleOpen}
+    />
+  );
+};
+
+export const FindingToolHandler = memo(function FindingToolHandler({
+  part,
+  status,
+}: {
+  part: any;
+  status: ChatStatus;
+}) {
+  const { toolCallId = "", state, input, output, errorText } = part;
+  const result = (output?.result ?? output ?? {}) as FindingOutput;
+  const target = input?.title || input?.target;
+
+  if (state === "input-streaming") {
+    return status === "streaming" ? (
+      <ToolBlock
+        icon={<ShieldAlert aria-hidden="true" />}
+        action="Preparing vulnerability report"
+        isShimmer={true}
+      />
+    ) : null;
+  }
+
+  if (state === "input-available") {
+    return status === "streaming" ? (
+      <ToolBlock
+        icon={<ShieldAlert aria-hidden="true" />}
+        action="Saving confirmed finding"
+        target={target}
+        isShimmer={true}
+      />
+    ) : null;
+  }
+
+  if (state === "output-error") {
+    return (
+      <ToolBlock
+        icon={<ShieldAlert aria-hidden="true" />}
+        action="Finding validation failed"
+        target={errorText || target}
+      />
+    );
+  }
+
+  if (state === "output-available") {
+    if (result.success === false) {
+      return (
+        <ToolBlock
+          icon={<ShieldAlert aria-hidden="true" />}
+          action={failureAction(result)}
+          target={result.message}
+        />
+      );
+    }
+
+    if (
+      result.success === true &&
+      result.finding_id &&
+      result.title &&
+      result.target &&
+      result.severity &&
+      typeof result.cvss_score === "number"
+    ) {
+      return (
+        <SavedFindingCard
+          output={{
+            finding_id: result.finding_id,
+            title: result.title,
+            target: result.target,
+            endpoint: result.endpoint,
+            severity: result.severity,
+            cvss_score: result.cvss_score,
+          }}
+          toolCallId={toolCallId}
+        />
+      );
+    }
+
+    return (
+      <ToolBlock
+        icon={<ShieldAlert aria-hidden="true" />}
+        action="Finding was not saved"
+        target="The tool returned an invalid result"
+      />
+    );
+  }
+
+  return null;
+});
diff --git a/app/components/tools/__tests__/FindingToolHandler.test.tsx b/app/components/tools/__tests__/FindingToolHandler.test.tsx
new file mode 100644
index 000000000..4937ee316
--- /dev/null
+++ b/app/components/tools/__tests__/FindingToolHandler.test.tsx
@@ -0,0 +1,138 @@
+import "@testing-library/jest-dom";
+import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { resetMockConvexQueries, setMockQueryResult } from "convex/react";
+
+const mockOpenInSidebar = jest.fn();
+const mockCapture = jest.fn();
+
+jest.mock("@/app/hooks/useToolSidebar", () => ({
+  useToolSidebar: () => ({
+    handleOpenInSidebar: mockOpenInSidebar,
+    handleKeyDown: jest.fn(),
+    isSidebarActive: false,
+  }),
+}));
+
+jest.mock("@/lib/analytics/client", () => ({
+  captureAuthenticatedEvent: mockCapture,
+}));
+
+const { FindingToolHandler } =
+  require("../FindingToolHandler") as typeof import("../FindingToolHandler");
+
+const successPart = {
+  toolCallId: "tool-1",
+  state: "output-available",
+  input: { title: "Confirmed IDOR", target: "app.example.test" },
+  output: {
+    success: true,
+    finding_id: "finding-1",
+    title: "Confirmed IDOR",
+    target: "app.example.test",
+    endpoint: "/api/invoices/other",
+    severity: "high",
+    cvss_score: 7.1,
+  },
+};
+
+describe("FindingToolHandler", () => {
+  beforeEach(() => {
+    resetMockConvexQueries();
+    jest.clearAllMocks();
+  });
+
+  it("renders streaming input and available input states", () => {
+    const { rerender } = render(
+      <FindingToolHandler
+        status="streaming"
+        part={{ toolCallId: "tool-1", state: "input-streaming" }}
+      />,
+    );
+    expect(screen.getByText("Preparing vulnerability report")).toBeVisible();
+
+    rerender(
+      <FindingToolHandler
+        status="streaming"
+        part={{
+          toolCallId: "tool-1",
+          state: "input-available",
+          input: { title: "Confirmed IDOR" },
+        }}
+      />,
+    );
+    expect(screen.getByText("Saving confirmed finding")).toBeVisible();
+    expect(screen.getByText("Confirmed IDOR")).toBeVisible();
+  });
+
+  it("renders a saved card, preserves it across remount, and opens on click", () => {
+    setMockQueryResult(undefined);
+    const first = render(
+      <FindingToolHandler status="ready" part={successPart} />,
+    );
+    expect(screen.getByText("Confirmed IDOR")).toBeVisible();
+    expect(screen.getByText("/api/invoices/other")).toBeVisible();
+    expect(screen.getByText(/high · 7\.1/i)).toBeVisible();
+
+    fireEvent.click(
+      screen.getByRole("button", { name: "Open finding: Confirmed IDOR" }),
+    );
+    expect(mockOpenInSidebar).toHaveBeenCalledTimes(1);
+    expect(mockCapture).toHaveBeenCalledWith("finding_viewed", {
+      surface: "inline_card",
+    });
+
+    first.unmount();
+    render(<FindingToolHandler status="ready" part={successPart} />);
+    expect(screen.getByText("Confirmed IDOR")).toBeVisible();
+  });
+
+  it.each([
+    ["validation", "Finding validation failed"],
+    ["duplicate", "Duplicate finding rejected"],
+    ["general", "Finding was not saved"],
+  ])("renders %s failures", (error, action) => {
+    render(
+      <FindingToolHandler
+        status="ready"
+        part={{
+          toolCallId: "tool-1",
+          state: "output-available",
+          output: { success: false, error, message: "Safe error message" },
+        }}
+      />,
+    );
+    expect(screen.getByText(action)).toBeVisible();
+    expect(screen.getByText("Safe error message")).toBeVisible();
+  });
+
+  it("renders tool execution errors", () => {
+    render(
+      <FindingToolHandler
+        status="ready"
+        part={{
+          toolCallId: "tool-1",
+          state: "output-error",
+          errorText: "Invalid CVE format",
+        }}
+      />,
+    );
+    expect(screen.getByText("Finding validation failed")).toBeVisible();
+    expect(screen.getByText("Invalid CVE format")).toBeVisible();
+  });
+
+  it("reactively replaces a card with the deleted state", () => {
+    setMockQueryResult(undefined);
+    const { rerender } = render(
+      <FindingToolHandler status="ready" part={successPart} />,
+    );
+    expect(screen.getByText("Confirmed IDOR")).toBeVisible();
+
+    setMockQueryResult(null);
+    rerender(<FindingToolHandler status="ready" part={{ ...successPart }} />);
+    expect(screen.getByText("Finding deleted")).toBeVisible();
+    expect(
+      screen.queryByRole("button", { name: /Open finding/i }),
+    ).not.toBeInTheDocument();
+  });
+});
diff --git a/app/hooks/useSidebarNavigation.ts b/app/hooks/useSidebarNavigation.ts
index 36a1612f2..03e4cfbae 100644
--- a/app/hooks/useSidebarNavigation.ts
+++ b/app/hooks/useSidebarNavigation.ts
@@ -9,6 +9,7 @@ import {
   isSidebarTerminal,
   isSidebarProxy,
   isSidebarWebSearch,
+  isSidebarFinding,
   type SidebarContent,
 } from "@/types/chat";
 
@@ -62,6 +63,9 @@ export const useSidebarNavigation = ({
       if (isSidebarWebSearch(item) && isSidebarWebSearch(sidebarContent)) {
         return item.toolCallId === sidebarContent.toolCallId;
       }
+      if (isSidebarFinding(item) && isSidebarFinding(sidebarContent)) {
+        return item.findingId === sidebarContent.findingId;
+      }
       return false;
     });
   }, [sidebarContent, toolExecutions]);
diff --git a/app/share/[shareId]/components/SharedMessagePartHandler.tsx b/app/share/[shareId]/components/SharedMessagePartHandler.tsx
index bb76cb9b4..227d13117 100644
--- a/app/share/[shareId]/components/SharedMessagePartHandler.tsx
+++ b/app/share/[shareId]/components/SharedMessagePartHandler.tsx
@@ -42,6 +42,7 @@ import {
 } from "@/app/components/tools/shell-tool-utils";
 import { PROXY_COMPLETED_LABELS } from "@/app/components/tools/ProxyToolHandler";
 import { isUserStoppedToolError } from "@/lib/chat/tool-abort-utils";
+import { FindingCard } from "@/app/components/findings/FindingCard";
 
 interface MessagePart {
   type: string;
@@ -52,6 +53,7 @@ interface MessagePart {
   output?: any;
   toolCallId?: string;
   errorText?: string;
+  data?: any;
 }
 
 interface SharedMessagePartHandlerProps {
@@ -108,6 +110,17 @@ export const SharedMessagePartHandler = ({
     );
   }
 
+  if (part.type === "data-shared-finding" && part.data) {
+    return (
+      <FindingCard
+        title={part.data.title}
+        target={part.data.target}
+        severity={part.data.severity}
+        cvssScore={part.data.cvss_score}
+      />
+    );
+  }
+
   // Terminal commands
   if (
     part.type === "data-terminal" ||
diff --git a/convex/__tests__/chats.agentApprovalLifecycle.test.ts b/convex/__tests__/chats.agentApprovalLifecycle.test.ts
index f417818eb..10a555034 100644
--- a/convex/__tests__/chats.agentApprovalLifecycle.test.ts
+++ b/convex/__tests__/chats.agentApprovalLifecycle.test.ts
@@ -94,6 +94,74 @@ describe("Agent approval lifecycle guards", () => {
     expect(patch).not.toHaveBeenCalled();
   });
 
+  it("cascades structured findings before deleting their source chat", async () => {
+    const tables: Record<string, Array<Record<string, any>>> = {
+      chats: [
+        {
+          _id: "chat-doc-1",
+          id: "chat-1",
+          user_id: "user-1",
+          canceled_at: 1,
+        },
+      ],
+      findings: [
+        {
+          _id: "finding-doc-1",
+          user_id: "user-1",
+          chat_id: "chat-1",
+          created_at: 1,
+        },
+      ],
+      messages: [],
+      chat_summaries: [],
+    };
+    const deleted: string[] = [];
+    const db = {
+      query: jest.fn((table: string) => ({
+        withIndex: jest.fn((_index: string, build: (q: any) => any) => {
+          const filters: Array<[string, unknown]> = [];
+          const q: any = {
+            eq: (field: string, value: unknown) => {
+              filters.push([field, value]);
+              return q;
+            },
+          };
+          build(q);
+          const rows = () =>
+            (tables[table] ?? []).filter((row) =>
+              filters.every(([field, value]) => row[field] === value),
+            );
+          return {
+            first: jest.fn(async () => rows()[0] ?? null),
+            take: jest.fn(async (limit: number) => rows().slice(0, limit)),
+          };
+        }),
+      })),
+      patch: jest.fn().mockResolvedValue(undefined),
+      delete: jest.fn(async (id: string) => {
+        deleted.push(id);
+        for (const [table, rows] of Object.entries(tables)) {
+          tables[table] = rows.filter((row) => row._id !== id);
+        }
+      }),
+    };
+
+    await expect(
+      deleteChatForBackend.handler(
+        { db, scheduler: { runAfter: jest.fn() } } as any,
+        {
+          serviceKey: "service-key",
+          chatId: "chat-1",
+          userId: "user-1",
+          expectedTriggerRunId: null,
+          expectedApprovalSessionId: null,
+        },
+      ),
+    ).resolves.toBe("deleted");
+
+    expect(deleted).toEqual(["finding-doc-1", "chat-doc-1"]);
+  });
+
   it("does not attach a new run after chat deletion starts", async () => {
     const { ctx, patch } = makeCtx({
       _id: "chat-doc-1",
diff --git a/convex/__tests__/findings.shared-security.test.ts b/convex/__tests__/findings.shared-security.test.ts
new file mode 100644
index 000000000..20b415f78
--- /dev/null
+++ b/convex/__tests__/findings.shared-security.test.ts
@@ -0,0 +1,67 @@
+import fs from "node:fs";
+import path from "node:path";
+import { sanitizeFindingPartsForShare } from "../../lib/findings/share-sanitizer";
+
+describe("shared finding security boundary", () => {
+  it("sanitizes both public reads and shared-chat forks on the server", () => {
+    const messagesSource = fs.readFileSync(
+      path.resolve(__dirname, "../messages.ts"),
+      "utf8",
+    );
+    const forksSource = fs.readFileSync(
+      path.resolve(__dirname, "../sharedChats.ts"),
+      "utf8",
+    );
+
+    for (const source of [messagesSource, forksSource]) {
+      expect(source).toMatch(/sanitizeFindingPartsForShare\(/);
+    }
+  });
+
+  it("never retains private input or internal identifiers in a forkable part", () => {
+    const serialized = JSON.stringify(
+      sanitizeFindingPartsForShare([
+        {
+          type: "tool-create_vulnerability_report",
+          toolCallId: "tool-secret",
+          state: "output-available",
+          input: {
+            title: "Confirmed IDOR",
+            target: "app.example.test",
+            evidence: "private evidence",
+            technical_analysis: "private analysis",
+            poc_script_code: "private exploit",
+            cve: "CVE-2026-12345",
+            cwe: "CWE-639",
+            code_locations: [{ file: "private.ts" }],
+          },
+          output: {
+            success: true,
+            finding_id: "finding-secret",
+            title: "Confirmed IDOR",
+            target: "app.example.test",
+            severity: "high",
+            cvss_score: 7.1,
+          },
+        },
+      ]),
+    );
+
+    expect(serialized).toBe(
+      JSON.stringify([
+        {
+          type: "data-shared-finding",
+          data: {
+            title: "Confirmed IDOR",
+            target: "app.example.test",
+            severity: "high",
+            cvss_score: 7.1,
+          },
+        },
+      ]),
+    );
+    expect(serialized).not.toMatch(
+      /tool-secret|finding-secret|private evidence|private analysis|private exploit|private\.ts|CVE|CWE/,
+    );
+  });
+});
diff --git a/convex/__tests__/findings.test.ts b/convex/__tests__/findings.test.ts
new file mode 100644
index 000000000..f06018414
--- /dev/null
+++ b/convex/__tests__/findings.test.ts
@@ -0,0 +1,467 @@
+import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+
+jest.mock("../_generated/server", () => ({
+  mutation: jest.fn((config: any) => config),
+  query: jest.fn((config: any) => config),
+}));
+
+jest.mock("convex/values", () => {
+  const actual =
+    jest.requireActual<typeof import("convex/values")>("convex/values");
+  return {
+    ...actual,
+    v: new Proxy({}, { get: () => jest.fn(() => "validator") }),
+  };
+});
+
+jest.mock("convex/server", () => ({
+  paginationOptsValidator: "paginationOptsValidator",
+}));
+
+jest.mock("../lib/utils", () => ({
+  validateServiceKey: jest.fn(),
+}));
+
+jest.mock("../lib/suspensionGuards", () => ({
+  assertUserCanAccessChatHistory: jest.fn().mockResolvedValue(undefined),
+}));
+
+type Row = { _id: string; [key: string]: any };
+type Tables = Record<string, Row[]>;
+
+const report = (overrides: Record<string, unknown> = {}) => ({
+  title: "Cross-tenant invoice access",
+  description: "An authenticated user can read another user's invoice.",
+  impact: "A user can disclose another customer's billing address.",
+  target: "https://app.example.test",
+  endpoint: "/api/invoices/:id",
+  method: "get",
+  cwe: "CWE-639",
+  technical_analysis: "The handler loads by id without an owner check.",
+  poc_description: "Request user B's invoice while signed in as user A.",
+  poc_script_code: "curl -H 'Authorization: Bearer user-a' /api/invoices/b",
+  remediation_steps: "Scope the invoice query to the authenticated user.",
+  evidence: "The response returned user B's billing address.",
+  assumptions: "Both accounts are ordinary customer accounts.",
+  fix_effort: "low",
+  cvss_breakdown: {
+    attack_vector: "N",
+    attack_complexity: "L",
+    privileges_required: "L",
+    user_interaction: "N",
+    scope: "U",
+    confidentiality: "H",
+    integrity: "N",
+    availability: "N",
+  },
+  ...overrides,
+});
+
+const seedTables = (): Tables => ({
+  chats: [
+    {
+      _id: "chat-doc-1",
+      id: "chat-1",
+      user_id: "user-1",
+      title: "Invoice test",
+      update_time: 1,
+    },
+    {
+      _id: "chat-doc-2",
+      id: "chat-2",
+      user_id: "user-1",
+      title: "Retest",
+      update_time: 2,
+    },
+    {
+      _id: "chat-doc-other",
+      id: "chat-other",
+      user_id: "other-user",
+      title: "Private other chat",
+      update_time: 3,
+    },
+  ],
+  messages: [
+    {
+      _id: "message-doc-1",
+      id: "message-1",
+      chat_id: "chat-1",
+      user_id: "user-1",
+      role: "assistant",
+      parts: [
+        { type: "text", text: "Confirmed." },
+        {
+          type: "tool-create_vulnerability_report",
+          toolCallId: "tool-1",
+          state: "output-available",
+          input: report(),
+          output: { success: true, finding_id: "finding-public-1" },
+        },
+        { type: "text", text: "Saved." },
+      ],
+      update_time: 1,
+    },
+  ],
+  findings: [],
+});
+
+function createResult(rows: Row[], filters: Array<[string, unknown]>) {
+  const filtered = () =>
+    rows.filter((row) =>
+      filters.every(([field, value]) => row[field] === value),
+    );
+  const result: any = {
+    first: jest.fn(async () => filtered()[0] ?? null),
+    collect: jest.fn(async () => filtered()),
+    take: jest.fn(async (limit: number) => filtered().slice(0, limit)),
+    order: jest.fn((direction: "asc" | "desc") => {
+      rows = [...filtered()].sort((a, b) =>
+        direction === "desc"
+          ? (b.created_at ?? 0) - (a.created_at ?? 0)
+          : (a.created_at ?? 0) - (b.created_at ?? 0),
+      );
+      filters = [];
+      return result;
+    }),
+    filter: jest.fn((build: (q: any) => any) => {
+      const q: any = {
+        field: (field: string) => field,
+        eq: (field: string, value: unknown) => {
+          filters.push([field, value]);
+          return q;
+        },
+      };
+      build(q);
+      return result;
+    }),
+    paginate: jest.fn(
+      async ({
+        cursor,
+        numItems,
+      }: {
+        cursor: string | null;
+        numItems: number;
+      }) => {
+        const all = filtered();
+        const start = cursor ? Number(cursor) : 0;
+        const page = all.slice(start, start + numItems);
+        const next = start + page.length;
+        return {
+          page,
+          isDone: next >= all.length,
+          continueCursor: next >= all.length ? "" : String(next),
+        };
+      },
+    ),
+  };
+  return result;
+}
+
+function createMockCtx(tables: Tables, subject = "user-1") {
+  let nextId = 1;
+  const query = jest.fn((table: string) => ({
+    withIndex: jest.fn((_index: string, build: (q: any) => any) => {
+      const filters: Array<[string, unknown]> = [];
+      const q: any = {
+        eq: (field: string, value: unknown) => {
+          filters.push([field, value]);
+          return q;
+        },
+      };
+      build(q);
+      return createResult(tables[table] ?? [], filters);
+    }),
+    withSearchIndex: jest.fn((_index: string, build: (q: any) => any) => {
+      const filters: Array<[string, unknown]> = [];
+      let search = "";
+      const q: any = {
+        search: (_field: string, value: string) => {
+          search = value.toLowerCase();
+          return q;
+        },
+        eq: (field: string, value: unknown) => {
+          filters.push([field, value]);
+          return q;
+        },
+      };
+      build(q);
+      const rows = (tables[table] ?? []).filter((row) =>
+        String(row.search_text ?? "")
+          .toLowerCase()
+          .includes(search),
+      );
+      return createResult(rows, filters);
+    }),
+  }));
+  const insert = jest.fn(async (table: string, value: Record<string, any>) => {
+    const row = { _id: `${table}-${nextId++}`, ...value };
+    (tables[table] ??= []).push(row);
+    return row._id;
+  });
+  const patch = jest.fn(async (id: string, value: Record<string, any>) => {
+    for (const rows of Object.values(tables)) {
+      const row = rows.find((candidate) => candidate._id === id);
+      if (row) Object.assign(row, value);
+    }
+  });
+  const deleteDoc = jest.fn(async (id: string) => {
+    for (const [table, rows] of Object.entries(tables)) {
+      tables[table] = rows.filter((candidate) => candidate._id !== id);
+    }
+  });
+
+  return {
+    ctx: {
+      auth: {
+        getUserIdentity: jest
+          .fn()
+          .mockResolvedValue(subject ? { subject } : null),
+      },
+      db: { query, insert, patch, delete: deleteDoc },
+    } as any,
+    insert,
+    patch,
+    deleteDoc,
+  };
+}
+
+const createArgs = (overrides: Record<string, unknown> = {}) => ({
+  serviceKey: "service-key",
+  userId: "user-1",
+  chatId: "chat-1",
+  messageId: "message-1",
+  toolCallId: "tool-1",
+  report: report(),
+  ...overrides,
+});
+
+describe("findings Convex lifecycle", () => {
+  beforeEach(() => jest.clearAllMocks());
+
+  it("persists server-derived provenance, score, severity, search, and dedupe", async () => {
+    const { createFindingForBackend } = await import("../findings");
+    const tables = seedTables();
+    const { ctx, insert } = createMockCtx(tables);
+
+    const result = await createFindingForBackend.handler(ctx, createArgs());
+
+    expect(result).toMatchObject({
+      success: true,
+      title: "Cross-tenant invoice access",
+      target: "https://app.example.test",
+      endpoint: "/api/invoices/:id",
+      severity: "medium",
+      cvss_score: 6.5,
+    });
+    expect(insert).toHaveBeenCalledWith(
+      "findings",
+      expect.objectContaining({
+        user_id: "user-1",
+        chat_id: "chat-1",
+        message_id: "message-1",
+        tool_call_id: "tool-1",
+        method: "GET",
+        severity: "medium",
+        cvss_score: 6.5,
+        cvss_vector: "CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N",
+        dedupe_key: expect.any(String),
+        search_text: expect.stringContaining("CWE-639"),
+        created_at: expect.any(Number),
+        updated_at: expect.any(Number),
+      }),
+    );
+  });
+
+  it("rejects a missing, deleted, or foreign source chat", async () => {
+    const { createFindingForBackend } = await import("../findings");
+    const tables = seedTables();
+    const { ctx } = createMockCtx(tables);
+
+    await expect(
+      createFindingForBackend.handler(
+        ctx,
+        createArgs({ chatId: "missing-chat" }),
+      ),
+    ).resolves.toMatchObject({ success: false, error: "chat_not_found" });
+    await expect(
+      createFindingForBackend.handler(
+        ctx,
+        createArgs({ chatId: "chat-other" }),
+      ),
+    ).resolves.toMatchObject({ success: false, error: "chat_not_found" });
+    tables.chats[0].deletion_started_at = Date.now();
+    await expect(
+      createFindingForBackend.handler(ctx, createArgs()),
+    ).resolves.toMatchObject({ success: false, error: "chat_not_found" });
+  });
+
+  it("deduplicates normalized reports in one chat but permits another chat", async () => {
+    const { createFindingForBackend } = await import("../findings");
+    const tables = seedTables();
+    const { ctx } = createMockCtx(tables);
+
+    await createFindingForBackend.handler(ctx, createArgs());
+    const duplicate = await createFindingForBackend.handler(
+      ctx,
+      createArgs({
+        toolCallId: "tool-2",
+        report: report({
+          title: "  CROSS-TENANT   invoice access ",
+          target: "HTTPS://APP.EXAMPLE.TEST",
+          method: "GET",
+          cwe: "CWE-639",
+        }),
+      }),
+    );
+    const crossChat = await createFindingForBackend.handler(
+      ctx,
+      createArgs({
+        chatId: "chat-2",
+        messageId: "message-2",
+        toolCallId: "tool-3",
+      }),
+    );
+
+    expect(duplicate).toMatchObject({ success: false, error: "duplicate" });
+    expect(crossChat).toMatchObject({ success: true });
+    expect(tables.findings).toHaveLength(2);
+  });
+
+  it("paginates newest-first and applies ownership, severity, chat, and search", async () => {
+    const { listFindings } = await import("../findings");
+    const tables = seedTables();
+    tables.findings = [
+      {
+        _id: "finding-old",
+        finding_id: "old",
+        user_id: "user-1",
+        chat_id: "chat-1",
+        title: "Old SQL injection",
+        target: "api.example.test",
+        severity: "critical",
+        cvss_score: 9.8,
+        search_text: "Old SQL injection api.example.test CWE-89",
+        created_at: 10,
+      },
+      {
+        _id: "finding-new",
+        finding_id: "new",
+        user_id: "user-1",
+        chat_id: "chat-2",
+        title: "New IDOR",
+        target: "app.example.test",
+        severity: "high",
+        cvss_score: 7.1,
+        search_text: "New IDOR app.example.test /invoices CWE-639",
+        created_at: 20,
+      },
+      {
+        _id: "finding-other",
+        finding_id: "other",
+        user_id: "other-user",
+        chat_id: "chat-other",
+        title: "Other private finding",
+        target: "private.test",
+        severity: "critical",
+        cvss_score: 10,
+        search_text: "Other private finding",
+        created_at: 30,
+      },
+    ];
+    const { ctx } = createMockCtx(tables);
+
+    const first = await listFindings.handler(ctx, {
+      paginationOpts: { cursor: null, numItems: 1 },
+    });
+    expect(first.page.map((item: any) => item.finding_id)).toEqual(["new"]);
+    expect(first.isDone).toBe(false);
+
+    const second = await listFindings.handler(ctx, {
+      paginationOpts: { cursor: first.continueCursor, numItems: 1 },
+    });
+    expect(second.page.map((item: any) => item.finding_id)).toEqual(["old"]);
+
+    const filtered = await listFindings.handler(ctx, {
+      paginationOpts: { cursor: null, numItems: 10 },
+      severity: "critical",
+      chatId: "chat-1",
+    });
+    expect(filtered.page.map((item: any) => item.finding_id)).toEqual(["old"]);
+
+    const searched = await listFindings.handler(ctx, {
+      paginationOpts: { cursor: null, numItems: 10 },
+      search: "CWE-639",
+    });
+    expect(searched.page.map((item: any) => item.finding_id)).toEqual(["new"]);
+  });
+
+  it("enforces read ownership", async () => {
+    const { getFinding } = await import("../findings");
+    const tables = seedTables();
+    tables.findings = [
+      {
+        _id: "finding-other",
+        finding_id: "other",
+        user_id: "other-user",
+        chat_id: "chat-other",
+        title: "Private",
+      },
+    ];
+    const { ctx } = createMockCtx(tables);
+    await expect(getFinding.handler(ctx, { findingId: "other" })).resolves.toBe(
+      null,
+    );
+  });
+
+  it("deletes an owned finding and scrubs its structured source tool part", async () => {
+    const { deleteFinding } = await import("../findings");
+    const tables = seedTables();
+    tables.findings = [
+      {
+        _id: "finding-doc-1",
+        finding_id: "finding-public-1",
+        user_id: "user-1",
+        chat_id: "chat-1",
+        message_id: "message-1",
+        tool_call_id: "tool-1",
+      },
+    ];
+    const { ctx, patch, deleteDoc } = createMockCtx(tables);
+
+    await expect(
+      deleteFinding.handler(ctx, { findingId: "finding-public-1" }),
+    ).resolves.toEqual({ deleted: true });
+    expect(patch).toHaveBeenCalledWith(
+      "message-doc-1",
+      expect.objectContaining({
+        parts: [
+          { type: "text", text: "Confirmed." },
+          { type: "text", text: "Saved." },
+        ],
+      }),
+    );
+    expect(deleteDoc).toHaveBeenCalledWith("finding-doc-1");
+  });
+
+  it("rejects deletion by a different user", async () => {
+    const { deleteFinding } = await import("../findings");
+    const tables = seedTables();
+    tables.findings = [
+      {
+        _id: "finding-doc-other",
+        finding_id: "finding-other",
+        user_id: "other-user",
+        chat_id: "chat-other",
+        message_id: "message-other",
+        tool_call_id: "tool-other",
+      },
+    ];
+    const { ctx, deleteDoc } = createMockCtx(tables);
+    await expect(
+      deleteFinding.handler(ctx, { findingId: "finding-other" }),
+    ).rejects.toMatchObject({
+      data: expect.objectContaining({ code: "ACCESS_DENIED" }),
+    });
+    expect(deleteDoc).not.toHaveBeenCalled();
+  });
+});
diff --git a/convex/__tests__/userDeletion.test.ts b/convex/__tests__/userDeletion.test.ts
index 85b8c80ce..d30fbf427 100644
--- a/convex/__tests__/userDeletion.test.ts
+++ b/convex/__tests__/userDeletion.test.ts
@@ -259,6 +259,22 @@ function seedTables(userId = "user_123", otherUserId = "user_other"): Tables {
       { _id: "note-user", user_id: userId, note_id: "note-1" },
       { _id: "note-other", user_id: otherUserId, note_id: "note-2" },
     ],
+    findings: [
+      {
+        _id: "finding-user",
+        finding_id: "finding-1",
+        user_id: userId,
+        chat_id: "chat-1",
+        created_at: 1,
+      },
+      {
+        _id: "finding-other",
+        finding_id: "finding-2",
+        user_id: otherUserId,
+        chat_id: "chat-other-id",
+        created_at: 1,
+      },
+    ],
     user_customization: [
       { _id: "custom-user", user_id: userId, updated_at: 1 },
       { _id: "custom-other", user_id: otherUserId, updated_at: 1 },
diff --git a/convex/_generated/api.d.ts b/convex/_generated/api.d.ts
index 7680281d6..5c0d75fa3 100644
--- a/convex/_generated/api.d.ts
+++ b/convex/_generated/api.d.ts
@@ -20,8 +20,12 @@ import type * as feedback from "../feedback.js";
 import type * as fileActions from "../fileActions.js";
 import type * as fileAggregate from "../fileAggregate.js";
 import type * as fileStorage from "../fileStorage.js";
+import type * as findings from "../findings.js";
+import type * as lib_extraUsagePricing from "../lib/extraUsagePricing.js";
+import type * as lib_extraUsageValidation from "../lib/extraUsageValidation.js";
 import type * as lib_logger from "../lib/logger.js";
 import type * as lib_retainedTail from "../lib/retainedTail.js";
+import type * as lib_suspensionGuards from "../lib/suspensionGuards.js";
 import type * as lib_utils from "../lib/utils.js";
 import type * as localSandbox from "../localSandbox.js";
 import type * as messages from "../messages.js";
@@ -62,8 +66,12 @@ declare const fullApi: ApiFromModules<{
   fileActions: typeof fileActions;
   fileAggregate: typeof fileAggregate;
   fileStorage: typeof fileStorage;
+  findings: typeof findings;
+  "lib/extraUsagePricing": typeof lib_extraUsagePricing;
+  "lib/extraUsageValidation": typeof lib_extraUsageValidation;
   "lib/logger": typeof lib_logger;
   "lib/retainedTail": typeof lib_retainedTail;
+  "lib/suspensionGuards": typeof lib_suspensionGuards;
   "lib/utils": typeof lib_utils;
   localSandbox: typeof localSandbox;
   messages: typeof messages;
diff --git a/convex/chats.ts b/convex/chats.ts
index 201cee9a1..fbcb89fef 100644
--- a/convex/chats.ts
+++ b/convex/chats.ts
@@ -28,6 +28,7 @@ import {
 
 const DELETE_ALL_CHATS_MESSAGE_BATCH_SIZE = 10;
 const DELETE_ALL_CHATS_SUMMARY_BATCH_SIZE = 25;
+const DELETE_ALL_CHATS_FINDING_BATCH_SIZE = 25;
 const CHAT_DELETION_FENCE_BATCH_SIZE = 100;
 const MAX_ACTIVE_TRIGGER_RUNS_TO_RETURN = 100;
 const CHAT_SUMMARY_TELEMETRY_CLEANUP_DEFAULT_BATCH_SIZE = 500;
@@ -248,9 +249,35 @@ async function deleteMessageForChatDeletion(
   await ctx.db.delete(message._id);
 }
 
+async function deleteFindingsForChatBatch(
+  ctx: MutationCtx,
+  chat: Doc<"chats">,
+): Promise<boolean> {
+  const findings = await ctx.db
+    .query("findings")
+    .withIndex("by_user_chat_created", (q) =>
+      q.eq("user_id", chat.user_id).eq("chat_id", chat.id),
+    )
+    .take(DELETE_ALL_CHATS_FINDING_BATCH_SIZE + 1);
+
+  for (const finding of findings.slice(
+    0,
+    DELETE_ALL_CHATS_FINDING_BATCH_SIZE,
+  )) {
+    await ctx.db.delete(finding._id);
+  }
+
+  return findings.length > DELETE_ALL_CHATS_FINDING_BATCH_SIZE;
+}
+
 async function deleteChatDocument(ctx: MutationCtx, chat: Doc<"chats">) {
   await prepareChatForDeletion(ctx, chat);
 
+  if (await deleteFindingsForChatBatch(ctx, chat)) {
+    await scheduleDeleteChatDocumentBatch(ctx, chat.id, chat.user_id);
+    return;
+  }
+
   const messages = await ctx.db
     .query("messages")
     .withIndex("by_chat_id", (q) => q.eq("chat_id", chat.id))
@@ -321,6 +348,11 @@ async function deleteNextUserChatBatch(ctx: MutationCtx, userId: string) {
 
   await prepareChatForDeletion(ctx, chat);
 
+  if (await deleteFindingsForChatBatch(ctx, chat)) {
+    await scheduleDeleteAllChatsBatch(ctx, userId);
+    return true;
+  }
+
   const messages = await ctx.db
     .query("messages")
     .withIndex("by_chat_id", (q) => q.eq("chat_id", chat.id))
@@ -1589,6 +1621,16 @@ export const deleteAllChatsForUser = mutation({
       .collect();
 
     for (const chat of userChats) {
+      const findings = await ctx.db
+        .query("findings")
+        .withIndex("by_user_chat_created", (q) =>
+          q.eq("user_id", args.userId).eq("chat_id", chat.id),
+        )
+        .collect();
+      for (const finding of findings) {
+        await ctx.db.delete(finding._id);
+      }
+
       const messages = await ctx.db
         .query("messages")
         .withIndex("by_chat_id", (q) => q.eq("chat_id", chat.id))
diff --git a/convex/findings.ts b/convex/findings.ts
new file mode 100644
index 000000000..b62577960
--- /dev/null
+++ b/convex/findings.ts
@@ -0,0 +1,332 @@
+import { mutation, query } from "./_generated/server";
+import { paginationOptsValidator } from "convex/server";
+import { ConvexError, v } from "convex/values";
+import { validateServiceKey } from "./lib/utils";
+import { assertUserCanAccessChatHistory } from "./lib/suspensionGuards";
+import { calculateCvss31 } from "../lib/findings/cvss31";
+import {
+  createFindingDedupeKey,
+  createFindingSearchText,
+  createVulnerabilityReportInputSchema,
+} from "../lib/findings/validation";
+import type { Doc } from "./_generated/dataModel";
+
+const MAX_SEARCH_LENGTH = 200;
+
+const getChat = async (ctx: any, chatId: string) =>
+  await ctx.db
+    .query("chats")
+    .withIndex("by_chat_id", (q: any) => q.eq("id", chatId))
+    .first();
+
+const getFindingByPublicId = async (ctx: any, findingId: string) =>
+  await ctx.db
+    .query("findings")
+    .withIndex("by_finding_id", (q: any) => q.eq("finding_id", findingId))
+    .first();
+
+const toFindingSummary = (finding: Doc<"findings">, chatTitle: string) => ({
+  finding_id: finding.finding_id,
+  title: finding.title,
+  target: finding.target,
+  ...(finding.endpoint ? { endpoint: finding.endpoint } : {}),
+  severity: finding.severity,
+  cvss_score: finding.cvss_score,
+  chat_id: finding.chat_id,
+  chat_title: chatTitle,
+  created_at: finding.created_at,
+});
+
+const toFindingDetail = (finding: Doc<"findings">, chatTitle: string) => ({
+  ...toFindingSummary(finding, chatTitle),
+  description: finding.description,
+  impact: finding.impact,
+  technical_analysis: finding.technical_analysis,
+  poc_description: finding.poc_description,
+  poc_script_code: finding.poc_script_code,
+  remediation_steps: finding.remediation_steps,
+  evidence: finding.evidence,
+  assumptions: finding.assumptions,
+  fix_effort: finding.fix_effort,
+  cvss_breakdown: finding.cvss_breakdown,
+  cvss_vector: finding.cvss_vector,
+  ...(finding.method ? { method: finding.method } : {}),
+  ...(finding.cve ? { cve: finding.cve } : {}),
+  ...(finding.cwe ? { cwe: finding.cwe } : {}),
+  ...(finding.code_locations ? { code_locations: finding.code_locations } : {}),
+  message_id: finding.message_id,
+  updated_at: finding.updated_at,
+});
+
+export const createFindingForBackend = mutation({
+  args: {
+    serviceKey: v.string(),
+    userId: v.string(),
+    chatId: v.string(),
+    messageId: v.string(),
+    toolCallId: v.string(),
+    report: v.any(),
+  },
+  handler: async (ctx, args) => {
+    validateServiceKey(args.serviceKey);
+
+    const parsed = createVulnerabilityReportInputSchema.safeParse(args.report);
+    if (!parsed.success) {
+      return {
+        success: false as const,
+        error: "validation" as const,
+        message: "The vulnerability report did not pass validation.",
+      };
+    }
+
+    const chat = await getChat(ctx, args.chatId);
+    if (
+      !chat ||
+      chat.user_id !== args.userId ||
+      chat.deletion_started_at ||
+      chat.canceled_at
+    ) {
+      return {
+        success: false as const,
+        error: "chat_not_found" as const,
+        message: "The source chat is no longer available.",
+      };
+    }
+
+    const input = parsed.data;
+    const dedupeKey = createFindingDedupeKey(input);
+    const duplicate = await ctx.db
+      .query("findings")
+      .withIndex("by_user_chat_dedupe", (q) =>
+        q
+          .eq("user_id", args.userId)
+          .eq("chat_id", args.chatId)
+          .eq("dedupe_key", dedupeKey),
+      )
+      .first();
+
+    if (duplicate) {
+      return {
+        success: false as const,
+        error: "duplicate" as const,
+        message: "A matching finding already exists in this chat.",
+      };
+    }
+
+    const findingId = crypto.randomUUID();
+    const now = Date.now();
+    const cvss = calculateCvss31(input.cvss_breakdown);
+    const method = input.method?.toUpperCase();
+
+    await ctx.db.insert("findings", {
+      finding_id: findingId,
+      user_id: args.userId,
+      chat_id: args.chatId,
+      message_id: args.messageId,
+      tool_call_id: args.toolCallId,
+      title: input.title,
+      description: input.description,
+      impact: input.impact,
+      target: input.target,
+      technical_analysis: input.technical_analysis,
+      poc_description: input.poc_description,
+      poc_script_code: input.poc_script_code,
+      remediation_steps: input.remediation_steps,
+      evidence: input.evidence,
+      assumptions: input.assumptions,
+      fix_effort: input.fix_effort,
+      cvss_breakdown: input.cvss_breakdown,
+      cvss_score: cvss.score,
+      cvss_vector: cvss.vector,
+      severity: cvss.severity,
+      ...(input.endpoint ? { endpoint: input.endpoint } : {}),
+      ...(method ? { method } : {}),
+      ...(input.cve ? { cve: input.cve } : {}),
+      ...(input.cwe ? { cwe: input.cwe } : {}),
+      ...(input.code_locations ? { code_locations: input.code_locations } : {}),
+      dedupe_key: dedupeKey,
+      search_text: createFindingSearchText(input),
+      created_at: now,
+      updated_at: now,
+    });
+
+    return {
+      success: true as const,
+      finding_id: findingId,
+      title: input.title,
+      target: input.target,
+      ...(input.endpoint ? { endpoint: input.endpoint } : {}),
+      severity: cvss.severity,
+      cvss_score: cvss.score,
+    };
+  },
+});
+
+export const getFinding = query({
+  args: { findingId: v.string() },
+  handler: async (ctx, args) => {
+    const identity = await ctx.auth.getUserIdentity();
+    if (!identity) return null;
+    await assertUserCanAccessChatHistory(ctx, identity.subject);
+
+    const finding = await getFindingByPublicId(ctx, args.findingId);
+    if (!finding || finding.user_id !== identity.subject) return null;
+
+    const chat = await getChat(ctx, finding.chat_id);
+    return toFindingDetail(finding, chat?.title ?? "Deleted chat");
+  },
+});
+
+export const listFindings = query({
+  args: {
+    paginationOpts: paginationOptsValidator,
+    search: v.optional(v.string()),
+    severity: v.optional(
+      v.union(
+        v.literal("critical"),
+        v.literal("high"),
+        v.literal("medium"),
+        v.literal("low"),
+        v.literal("info"),
+      ),
+    ),
+    chatId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const identity = await ctx.auth.getUserIdentity();
+    if (!identity) {
+      return { page: [], isDone: true, continueCursor: "" };
+    }
+    await assertUserCanAccessChatHistory(ctx, identity.subject);
+
+    const search = args.search?.trim().slice(0, MAX_SEARCH_LENGTH);
+    let page: Doc<"findings">[];
+    let isDone: boolean;
+    let continueCursor: string;
+
+    if (search) {
+      const result = await ctx.db
+        .query("findings")
+        .withSearchIndex("search_findings", (q) => {
+          let builder = q
+            .search("search_text", search)
+            .eq("user_id", identity.subject);
+          if (args.severity) builder = builder.eq("severity", args.severity);
+          if (args.chatId) builder = builder.eq("chat_id", args.chatId);
+          return builder;
+        })
+        .paginate(args.paginationOpts);
+
+      page = result.page;
+      isDone = result.isDone;
+      continueCursor = result.continueCursor;
+    } else {
+      let findingsQuery;
+      if (args.severity) {
+        findingsQuery = ctx.db
+          .query("findings")
+          .withIndex("by_user_severity_created", (q) =>
+            q.eq("user_id", identity.subject).eq("severity", args.severity!),
+          );
+      } else if (args.chatId) {
+        findingsQuery = ctx.db
+          .query("findings")
+          .withIndex("by_user_chat_created", (q) =>
+            q.eq("user_id", identity.subject).eq("chat_id", args.chatId!),
+          );
+      } else {
+        findingsQuery = ctx.db
+          .query("findings")
+          .withIndex("by_user_and_created", (q) =>
+            q.eq("user_id", identity.subject),
+          );
+      }
+
+      if (args.severity && args.chatId) {
+        findingsQuery = findingsQuery.filter((q: any) =>
+          q.eq(q.field("chat_id"), args.chatId),
+        );
+      }
+
+      const result = await findingsQuery
+        .order("desc")
+        .paginate(args.paginationOpts);
+      page = result.page;
+      isDone = result.isDone;
+      continueCursor = result.continueCursor;
+    }
+
+    const summaries = await Promise.all(
+      page.map(async (finding) => {
+        const chat = await getChat(ctx, finding.chat_id);
+        return toFindingSummary(finding, chat?.title ?? "Deleted chat");
+      }),
+    );
+
+    return { page: summaries, isDone, continueCursor };
+  },
+});
+
+export const getFindingSourceChats = query({
+  args: {},
+  handler: async (ctx) => {
+    const identity = await ctx.auth.getUserIdentity();
+    if (!identity) return [];
+    await assertUserCanAccessChatHistory(ctx, identity.subject);
+
+    const chats = await ctx.db
+      .query("chats")
+      .withIndex("by_user_and_updated", (q) =>
+        q.eq("user_id", identity.subject),
+      )
+      .order("desc")
+      .collect();
+    return chats.map((chat) => ({
+      chat_id: chat.id,
+      chat_title: chat.title,
+    }));
+  },
+});
+
+export const deleteFinding = mutation({
+  args: { findingId: v.string() },
+  handler: async (ctx, args) => {
+    const identity = await ctx.auth.getUserIdentity();
+    if (!identity) {
+      throw new ConvexError({ code: "UNAUTHORIZED", message: "Unauthorized" });
+    }
+    await assertUserCanAccessChatHistory(ctx, identity.subject);
+
+    const finding = await getFindingByPublicId(ctx, args.findingId);
+    if (!finding) return { deleted: false };
+    if (finding.user_id !== identity.subject) {
+      throw new ConvexError({
+        code: "ACCESS_DENIED",
+        message: "Access denied",
+      });
+    }
+
+    const message = await ctx.db
+      .query("messages")
+      .withIndex("by_message_id", (q) => q.eq("id", finding.message_id))
+      .first();
+    if (
+      message &&
+      message.user_id === identity.subject &&
+      message.chat_id === finding.chat_id
+    ) {
+      const scrubbedParts = message.parts.filter(
+        (part: any) => part?.toolCallId !== finding.tool_call_id,
+      );
+      if (scrubbedParts.length !== message.parts.length) {
+        await ctx.db.patch(message._id, {
+          parts: scrubbedParts,
+          update_time: Date.now(),
+        });
+      }
+    }
+
+    await ctx.db.delete(finding._id);
+    return { deleted: true };
+  },
+});
diff --git a/convex/messages.ts b/convex/messages.ts
index f154960cb..faed2c050 100644
--- a/convex/messages.ts
+++ b/convex/messages.ts
@@ -16,6 +16,7 @@ import {
   isUserBlockedByActiveFraudDispute,
 } from "./lib/suspensionGuards";
 import { stripOpenRouterReasoningMetadataFromParts } from "../lib/chat/provider-metadata-sanitizer";
+import { sanitizeFindingPartsForShare } from "../lib/findings/share-sanitizer";
 import {
   MAX_MESSAGE_SEARCH_QUERY_LENGTH,
   MIN_MESSAGE_SEARCH_QUERY_LENGTH,
@@ -2115,22 +2116,22 @@ export const getSharedMessages = query({
         content: msg.content,
         update_time: msg.update_time,
         // Process parts to replace files/images with placeholders
-        parts: stripOpenRouterReasoningMetadataFromParts(msg.parts).map(
-          (part: any) => {
-            // Replace file references with placeholder
-            if (part.type === "file") {
-              // Determine if it's an image based on mediaType
-              const isImage = part.mediaType?.startsWith("image/");
-              return {
-                type: isImage ? "image" : "file",
-                placeholder: true,
-                // SECURITY: Do NOT include url, file_id, name, or mediaType
-              };
-            }
-            // Keep text parts as-is
-            return part;
-          },
-        ),
+        parts: sanitizeFindingPartsForShare(
+          stripOpenRouterReasoningMetadataFromParts(msg.parts),
+        ).map((part: any) => {
+          // Replace file references with placeholder
+          if (part.type === "file") {
+            // Determine if it's an image based on mediaType
+            const isImage = part.mediaType?.startsWith("image/");
+            return {
+              type: isImage ? "image" : "file",
+              placeholder: true,
+              // SECURITY: Do NOT include url, file_id, name, or mediaType
+            };
+          }
+          // Keep text parts as-is
+          return part;
+        }),
         // SECURITY: user_id is NOT included in response (anonymity)
       }));
     } catch (error) {
diff --git a/convex/schema.ts b/convex/schema.ts
index 9cfe5870d..2dc9b1524 100644
--- a/convex/schema.ts
+++ b/convex/schema.ts
@@ -49,6 +49,30 @@ const agentApprovalTargetGrantValidator = v.union(
   }),
 );
 
+const findingSeverityValidator = v.union(
+  v.literal("critical"),
+  v.literal("high"),
+  v.literal("medium"),
+  v.literal("low"),
+  v.literal("info"),
+);
+
+const cvss31BreakdownValidator = v.object({
+  attack_vector: v.union(
+    v.literal("N"),
+    v.literal("A"),
+    v.literal("L"),
+    v.literal("P"),
+  ),
+  attack_complexity: v.union(v.literal("L"), v.literal("H")),
+  privileges_required: v.union(v.literal("N"), v.literal("L"), v.literal("H")),
+  user_interaction: v.union(v.literal("N"), v.literal("R")),
+  scope: v.union(v.literal("U"), v.literal("C")),
+  confidentiality: v.union(v.literal("N"), v.literal("L"), v.literal("H")),
+  integrity: v.union(v.literal("N"), v.literal("L"), v.literal("H")),
+  availability: v.union(v.literal("N"), v.literal("L"), v.literal("H")),
+});
+
 export default defineSchema({
   chats: defineTable({
     id: v.string(),
@@ -174,6 +198,64 @@ export default defineSchema({
       filterFields: ["user_id"],
     }),
 
+  findings: defineTable({
+    finding_id: v.string(),
+    user_id: v.string(),
+    chat_id: v.string(),
+    message_id: v.string(),
+    tool_call_id: v.string(),
+    title: v.string(),
+    description: v.string(),
+    impact: v.string(),
+    target: v.string(),
+    technical_analysis: v.string(),
+    poc_description: v.string(),
+    poc_script_code: v.string(),
+    remediation_steps: v.string(),
+    evidence: v.string(),
+    assumptions: v.string(),
+    fix_effort: v.union(
+      v.literal("trivial"),
+      v.literal("low"),
+      v.literal("medium"),
+      v.literal("high"),
+    ),
+    cvss_breakdown: cvss31BreakdownValidator,
+    cvss_score: v.number(),
+    cvss_vector: v.string(),
+    severity: findingSeverityValidator,
+    endpoint: v.optional(v.string()),
+    method: v.optional(v.string()),
+    cve: v.optional(v.string()),
+    cwe: v.optional(v.string()),
+    code_locations: v.optional(
+      v.array(
+        v.object({
+          file: v.string(),
+          start_line: v.number(),
+          end_line: v.number(),
+          snippet: v.optional(v.string()),
+          label: v.optional(v.string()),
+          fix_before: v.optional(v.string()),
+          fix_after: v.optional(v.string()),
+        }),
+      ),
+    ),
+    dedupe_key: v.string(),
+    search_text: v.string(),
+    created_at: v.number(),
+    updated_at: v.number(),
+  })
+    .index("by_finding_id", ["finding_id"])
+    .index("by_user_and_created", ["user_id", "created_at"])
+    .index("by_user_severity_created", ["user_id", "severity", "created_at"])
+    .index("by_user_chat_created", ["user_id", "chat_id", "created_at"])
+    .index("by_user_chat_dedupe", ["user_id", "chat_id", "dedupe_key"])
+    .searchIndex("search_findings", {
+      searchField: "search_text",
+      filterFields: ["user_id", "severity", "chat_id"],
+    }),
+
   files: defineTable({
     s3_key: v.optional(v.string()),
     user_id: v.string(),
diff --git a/convex/sharedChats.ts b/convex/sharedChats.ts
index 6c3dc0452..dc6bbf368 100644
--- a/convex/sharedChats.ts
+++ b/convex/sharedChats.ts
@@ -6,6 +6,7 @@ import {
   isUserBlockedByActiveFraudDispute,
 } from "./lib/suspensionGuards";
 import { stripOpenRouterReasoningMetadataFromParts } from "../lib/chat/provider-metadata-sanitizer";
+import { sanitizeFindingPartsForShare } from "../lib/findings/share-sanitizer";
 
 /**
  * Share a chat by creating a public share link.
@@ -366,8 +367,8 @@ export const forkSharedChat = mutation({
       // Remove file/image parts entirely — the forking user doesn't own the
       // original files, signed URLs will expire, and placeholder parts render
       // as broken "Unknown file" cards in the regular chat view.
-      const sanitizedParts = stripOpenRouterReasoningMetadataFromParts(
-        msg.parts,
+      const sanitizedParts = sanitizeFindingPartsForShare(
+        stripOpenRouterReasoningMetadataFromParts(msg.parts),
       ).filter((part: any) => part.type !== "file");
       await ctx.db.insert("messages", {
         id: newMessageId,
diff --git a/convex/userDeletion.ts b/convex/userDeletion.ts
index 6e187b73f..0a7fa53dc 100644
--- a/convex/userDeletion.ts
+++ b/convex/userDeletion.ts
@@ -14,6 +14,7 @@ export const USER_DELETION_TABLE_POLICY = {
     "messages",
     "files",
     "feedback",
+    "findings",
     "notes",
     "user_customization",
     "extra_usage",
@@ -362,6 +363,13 @@ async function cleanupUserDataForUser(
     "by_user_and_updated",
     (q) => q.eq("user_id", userId),
   );
+  const findingsBatch = await collectByIndexBatch<Doc<"findings">>(
+    ctx,
+    budget,
+    "findings",
+    "by_user_and_created",
+    (q) => q.eq("user_id", userId),
+  );
   const customizationBatch = await collectByIndexBatch<
     Doc<"user_customization">
   >(ctx, budget, "user_customization", "by_user_id", (q) =>
@@ -409,6 +417,7 @@ async function cleanupUserDataForUser(
   const deletionBatches = [
     chatsBatch,
     filesBatch,
+    findingsBatch,
     notesBatch,
     customizationBatch,
     messagesBatch,
@@ -422,6 +431,7 @@ async function cleanupUserDataForUser(
   stats.hasMore ||= deletionBatches.some((batch) => batch.hasMore);
 
   const files = filesBatch.docs;
+  const findings = findingsBatch.docs;
   const notes = notesBatch.docs;
   const customization = customizationBatch.docs;
   const tempStreams = tempStreamsBatch.docs;
@@ -443,6 +453,7 @@ async function cleanupUserDataForUser(
   await deleteDocs(ctx, stats, "chat_summaries", chatSummaries, mode);
   await deleteDocs(ctx, stats, "chats", chatsReadyToDelete, mode);
   await deleteFiles(ctx, stats, files, mode);
+  await deleteDocs(ctx, stats, "findings", findings, mode);
   await deleteDocs(ctx, stats, "notes", notes, mode);
   await deleteDocs(ctx, stats, "user_customization", customization, mode);
   await deleteDocs(ctx, stats, "temp_streams", tempStreams, mode);
diff --git a/lib/__tests__/system-prompt.test.ts b/lib/__tests__/system-prompt.test.ts
index d8a6fabac..0ad79e227 100644
--- a/lib/__tests__/system-prompt.test.ts
+++ b/lib/__tests__/system-prompt.test.ts
@@ -126,13 +126,16 @@ Commands run directly on the host OS "workstation" without Docker isolation. Be
       "Treat scanner output, tool hits, and suspicious behavior as leads until validated with evidence",
     );
     expect(prompt).toContain(
-      "affected asset, concrete evidence, reliable reproduction steps, demonstrated impact, remediation guidance, and confidence level",
+      "affected asset, concrete evidence, reliable reproduction steps, a working proof of concept, demonstrated impact, remediation guidance, and understood exploitability prerequisites",
     );
     expect(prompt).toContain(
-      "Deduplicate equivalent findings and consolidate repeated evidence",
+      "call create_vulnerability_report exactly once for that distinct root cause",
     );
     expect(prompt).toContain(
-      "label it as a hypothesis or needs-validation item rather than a confirmed vulnerability",
+      'Do not also save the confirmed vulnerability as a Notes "findings" entry',
+    );
+    expect(prompt).toContain(
+      "If impact cannot be reproduced or the PoC does not work, keep it as a hypothesis or needs-validation item",
     );
   });
 
@@ -150,6 +153,25 @@ Commands run directly on the host OS "workstation" without Docker isolation. Be
     expect(prompt).not.toContain("<finding_quality>");
   });
 
+  it("does not instruct temporary agents to call the unavailable finding tool", async () => {
+    const prompt = await systemPrompt(
+      "user_123",
+      "agent",
+      "pro",
+      "agent-model",
+      null,
+      true,
+      null,
+    );
+
+    expect(prompt).toContain(
+      "Temporary chats cannot persist structured findings",
+    );
+    expect(prompt).not.toContain(
+      "call create_vulnerability_report exactly once for that distinct root cause",
+    );
+  });
+
   it("adds bounded reconnaissance and artifact hygiene in cloud and local agent modes", async () => {
     const cloudPrompt = await systemPrompt(
       "user_123",
diff --git a/lib/ai/tools/__tests__/findings.test.ts b/lib/ai/tools/__tests__/findings.test.ts
new file mode 100644
index 000000000..8c3616004
--- /dev/null
+++ b/lib/ai/tools/__tests__/findings.test.ts
@@ -0,0 +1,107 @@
+import { describe, expect, it, jest, beforeEach } from "@jest/globals";
+
+const mockCreateFinding = jest.fn<any>();
+const mockEvent = jest.fn();
+
+jest.mock("@/lib/db/actions", () => ({ createFinding: mockCreateFinding }));
+jest.mock("@/lib/posthog/server", () => ({
+  phLogger: { event: mockEvent },
+}));
+
+const input = {
+  title: "Confirmed IDOR",
+  description: "Another account's invoice is readable.",
+  impact: "Billing data disclosure.",
+  target: "app.example.test",
+  technical_analysis: "The handler omits an owner predicate.",
+  poc_description: "Request another account's invoice.",
+  poc_script_code: "curl /api/invoices/other",
+  remediation_steps: "Add an owner predicate.",
+  evidence: "HTTP 200 returned the other account's data.",
+  assumptions: "Ordinary authenticated account.",
+  fix_effort: "low" as const,
+  cvss_breakdown: {
+    attack_vector: "N" as const,
+    attack_complexity: "L" as const,
+    privileges_required: "L" as const,
+    user_interaction: "N" as const,
+    scope: "U" as const,
+    confidentiality: "H" as const,
+    integrity: "N" as const,
+    availability: "N" as const,
+  },
+};
+
+describe("create_vulnerability_report execution", () => {
+  beforeEach(() => jest.clearAllMocks());
+
+  it("returns compact persistence data and emits content-free creation analytics", async () => {
+    const compact = {
+      success: true,
+      finding_id: "finding-1",
+      title: input.title,
+      target: input.target,
+      severity: "high",
+      cvss_score: 7.1,
+    };
+    mockCreateFinding.mockResolvedValue(compact);
+    const { createCreateVulnerabilityReport } = await import("../findings");
+    const tool = createCreateVulnerabilityReport({
+      userID: "user-1",
+      chatId: "chat-1",
+      assistantMessageId: "message-1",
+    } as any) as any;
+
+    await expect(
+      tool.execute(input, { toolCallId: "tool-1" }),
+    ).resolves.toEqual(compact);
+    expect(mockCreateFinding).toHaveBeenCalledWith({
+      userId: "user-1",
+      chatId: "chat-1",
+      messageId: "message-1",
+      toolCallId: "tool-1",
+      report: input,
+    });
+    expect(mockEvent).toHaveBeenCalledWith("finding_created", {
+      userId: "user-1",
+    });
+    expect(JSON.stringify(mockEvent.mock.calls)).not.toMatch(
+      /Confirmed IDOR|app\.example|HTTP 200|curl/,
+    );
+  });
+
+  it("reports deterministic duplicate rejection without retrying", async () => {
+    mockCreateFinding.mockResolvedValue({
+      success: false,
+      error: "duplicate",
+      message: "A matching finding already exists in this chat.",
+    });
+    const { createCreateVulnerabilityReport } = await import("../findings");
+    const tool = createCreateVulnerabilityReport({
+      userID: "user-1",
+      chatId: "chat-1",
+      assistantMessageId: "message-1",
+    } as any) as any;
+
+    await expect(
+      tool.execute(input, { toolCallId: "tool-2" }),
+    ).resolves.toMatchObject({ success: false, error: "duplicate" });
+    expect(mockCreateFinding).toHaveBeenCalledTimes(1);
+    expect(mockEvent).toHaveBeenCalledWith("finding_duplicate_rejected", {
+      userId: "user-1",
+    });
+  });
+
+  it("does not persist without assistant-message provenance", async () => {
+    const { createCreateVulnerabilityReport } = await import("../findings");
+    const tool = createCreateVulnerabilityReport({
+      userID: "user-1",
+      chatId: "chat-1",
+    } as any) as any;
+
+    await expect(
+      tool.execute(input, { toolCallId: "tool-3" }),
+    ).resolves.toMatchObject({ success: false, error: "general" });
+    expect(mockCreateFinding).not.toHaveBeenCalled();
+  });
+});
diff --git a/lib/ai/tools/__tests__/schemas.test.ts b/lib/ai/tools/__tests__/schemas.test.ts
index 4d9b417ad..bd44f5995 100644
--- a/lib/ai/tools/__tests__/schemas.test.ts
+++ b/lib/ai/tools/__tests__/schemas.test.ts
@@ -1,6 +1,8 @@
 import {
+  createAgentToolSchemaSet,
   createFileToolSchema,
   createRunTerminalCmdToolSchema,
+  createVulnerabilityReportToolInputSchema,
   runTerminalCmdTool,
 } from "../schemas";
 
@@ -12,6 +14,41 @@ const getInputShape = (value: unknown): Record<string, unknown> =>
     .shape;
 
 describe("agent tool schema descriptions", () => {
+  test("exposes structured findings only in persistent Agent modes", () => {
+    expect(createAgentToolSchemaSet({ mode: "agent" })).toHaveProperty(
+      "create_vulnerability_report",
+    );
+    expect(createAgentToolSchemaSet({ mode: "ask" })).not.toHaveProperty(
+      "create_vulnerability_report",
+    );
+    expect(
+      createAgentToolSchemaSet({ mode: "agent", isTemporary: true }),
+    ).not.toHaveProperty("create_vulnerability_report");
+  });
+
+  test("uses the complete strict report schema in the model-facing contract", () => {
+    const parsed = createVulnerabilityReportToolInputSchema.safeParse({});
+    expect(parsed.success).toBe(false);
+    if (!parsed.success) {
+      expect(parsed.error.issues.map((issue) => issue.path[0])).toEqual(
+        expect.arrayContaining([
+          "title",
+          "description",
+          "impact",
+          "target",
+          "technical_analysis",
+          "poc_description",
+          "poc_script_code",
+          "remediation_steps",
+          "evidence",
+          "assumptions",
+          "fix_effort",
+          "cvss_breakdown",
+        ]),
+      );
+    }
+  });
+
   test("terminal command approval wording is mode-specific", () => {
     const fullAccessDescription = getDescription(runTerminalCmdTool);
     expect(fullAccessDescription).not.toContain("ask the user to approve it");
diff --git a/lib/ai/tools/findings.ts b/lib/ai/tools/findings.ts
new file mode 100644
index 000000000..ecce029ce
--- /dev/null
+++ b/lib/ai/tools/findings.ts
@@ -0,0 +1,56 @@
+import { tool } from "ai";
+import type { ToolContext } from "@/types";
+import { createFinding } from "@/lib/db/actions";
+import { phLogger } from "@/lib/posthog/server";
+import {
+  createVulnerabilityReportTool,
+  type CreateVulnerabilityReportInput,
+} from "./schemas";
+
+export const createCreateVulnerabilityReport = (context: ToolContext) =>
+  tool({
+    ...createVulnerabilityReportTool,
+    execute: async (input: CreateVulnerabilityReportInput, { toolCallId }) => {
+      if (!context.assistantMessageId) {
+        return {
+          success: false as const,
+          error: "general" as const,
+          message:
+            "Finding provenance is unavailable. The report was not saved.",
+        };
+      }
+
+      try {
+        const result = await createFinding({
+          userId: context.userID,
+          chatId: context.chatId,
+          messageId: context.assistantMessageId,
+          toolCallId,
+          report: input,
+        });
+
+        if (!result.success && result.error === "duplicate") {
+          phLogger.event("finding_duplicate_rejected", {
+            userId: context.userID,
+          });
+        } else if (result.success) {
+          phLogger.event("finding_created", { userId: context.userID });
+        }
+
+        return result;
+      } catch (error) {
+        console.error("Create vulnerability report tool failed", {
+          error_name: error instanceof Error ? error.name : typeof error,
+        });
+        return {
+          success: false as const,
+          error: "general" as const,
+          message:
+            "The finding could not be saved. Do not assume it persisted.",
+        };
+      }
+    },
+    toModelOutput({ output }) {
+      return { type: "text" as const, value: JSON.stringify(output) };
+    },
+  });
diff --git a/lib/ai/tools/index.ts b/lib/ai/tools/index.ts
index d03664486..f6026310f 100644
--- a/lib/ai/tools/index.ts
+++ b/lib/ai/tools/index.ts
@@ -17,6 +17,7 @@ import {
   createUpdateNote,
   createDeleteNote,
 } from "./notes";
+import { createCreateVulnerabilityReport } from "./findings";
 // match tool removed — usage analytics showed it wasn't being used enough to justify
 // the added complexity. The agent should use run_terminal_cmd with rg instead.
 // import { createMatch } from "./match";
@@ -144,6 +145,9 @@ export const createTools = (
       get_terminal_files: createGetTerminalFiles(context),
       file: createFile(context),
       todo_write: createTodoWrite(context),
+      ...(!isTemporary && {
+        create_vulnerability_report: createCreateVulnerabilityReport(context),
+      }),
       ...(!isTemporary &&
         notesEnabled && {
           create_note: createCreateNote(context),
diff --git a/lib/ai/tools/schemas.ts b/lib/ai/tools/schemas.ts
index 8d0b5b743..7d9c3ab31 100644
--- a/lib/ai/tools/schemas.ts
+++ b/lib/ai/tools/schemas.ts
@@ -567,7 +567,7 @@ export const createNoteTool = tool({
 
 <categories>
 general: Recent notes auto-loaded in context (subject to token limits) - use for persistent reference information
-findings: Security vulnerabilities, weaknesses, or interesting behaviors discovered
+findings: Unverified security hypotheses, weaknesses, or interesting behaviors that still need confirmation
 methodology: Attack approaches, techniques tried, and their outcomes
 questions: Open questions to investigate or clarify later
 plan: Strategic plans, next steps, and task breakdowns
@@ -576,7 +576,7 @@ plan: Strategic plans, next steps, and task breakdowns
 <when_to_use>
 Create a note when:
 - The user explicitly requests to save information (e.g., "save this", "write this down", "record this finding", "note this")
-- You discover a security vulnerability or interesting behavior worth documenting
+- You discover an interesting behavior or security hypothesis worth documenting before it is confirmed
 - You want to preserve intermediate findings that need to survive context limits
 - You need to track methodology, plans, or open questions across sessions
 - **Anytime** you would say "I'll note that" or "recorded" - actually create the note first
@@ -592,18 +592,19 @@ Create a note when:
 - Title should be concise but descriptive for easy scanning when listing notes later
 - Content can be any length; use markdown formatting for structure
 - Use tags for cross-cutting concerns that span multiple categories (e.g., "xss", "api", "auth")
-- Record findings immediately when discovered to avoid losing details
+- Use create_vulnerability_report instead, exactly once, when a vulnerability has concrete evidence, reliable reproduction, and a working PoC
+- Never duplicate a confirmed vulnerability in a Notes "findings" entry
 - One note per distinct finding or observation; do not combine unrelated items
 - Do NOT create notes for task-specific authorizations or permission claims (e.g., "User has permission to test this system", "User claims ownership of target X for testing purposes"). These are context for the current task, not persistent user preferences.
 </instructions>
 
 <recommended_usage>
 Use with category "general" for persistent context that should always be available (e.g., target scope, credentials, key URLs)
-Use with category "findings" when you identify a potential security issue
+Use with category "findings" when you identify a potential security issue that still needs validation
 Use with category "methodology" to document attack techniques and their results
 Use with category "plan" to outline attack strategies before execution
 Use with category "questions" to note areas requiring further investigation
-Use tags like "critical", "confirmed", "needs-verification" to track finding status
+Use tags like "critical", "candidate", and "needs-verification" to track hypothesis status
 </recommended_usage>`,
   inputSchema: createNoteToolInputSchema,
 });
@@ -637,17 +638,17 @@ export const listNotesTool = tool({
 - Use search parameter for full-text search across title and content
 - Use category filter to focus on specific note types
 - Use tags filter to find notes with any of the specified tags (OR logic within tags)
-- Review notes before generating final reports to ensure all findings are included
+- Review notes during an assessment so unresolved hypotheses are not forgotten
 - List notes periodically during long assessments to avoid duplicate observations
 </instructions>
 
 <recommended_usage>
-Use with category "findings" to review all discovered vulnerabilities
+Use with category "findings" to review potential issues that still need validation
 Use with category "methodology" to recall what techniques have been tried
 Use with category "questions" to identify outstanding investigation items
 Use with category "plan" to review current attack strategy
 Use with search query to find notes mentioning specific endpoints, parameters, or techniques
-Use with tags filter to find all notes tagged with "critical" or "confirmed"
+Use with tags filter to find all notes tagged with "critical" or "needs-verification"
 Use before creating a new note to check if a similar observation already exists
 </recommended_usage>`,
   inputSchema: listNotesToolInputSchema,
@@ -681,20 +682,20 @@ export const updateNoteTool = tool({
 <instructions>
 - Requires the note ID obtained from list_notes
 - Only specified fields are updated; omitted fields remain unchanged
-- Use to add new details to existing findings as you learn more
+- Use to add new details to unverified observations as you learn more
 - Use to correct errors or refine observations
-- Use to update tags when finding status changes (e.g., adding "confirmed" after verification)
+- Use to update tags as a hypothesis moves through validation
 - Prefer updating existing notes over creating duplicates when information evolves
 - Category cannot be changed after creation; create a new note if recategorization is needed
 </instructions>
 
 <recommended_usage>
-Use to add reproduction steps after confirming a vulnerability
-Use to append additional affected endpoints to an existing finding
-Use to update tags from "needs-verification" to "confirmed" after validation
+Use to add investigation steps to an unverified observation
+Use to append candidate affected endpoints while validation is still in progress
+Use to refine hypotheses without claiming they are confirmed reports
 Use to refine plan notes as the assessment progresses
 Use to correct mistakes in previously recorded observations
-Use to add technical details or evidence to a finding
+Use to add technical details or evidence to an unverified hypothesis
 </recommended_usage>`,
   inputSchema: updateNoteToolInputSchema,
 });
@@ -717,7 +718,7 @@ export const deleteNoteTool = tool({
 - Delete notes that are confirmed false positives to reduce noise
 - Delete duplicate notes after consolidating information
 - Delete plan notes that are no longer relevant after strategy changes
-- Do not delete findings notes unless confirmed to be completely invalid
+- Delete obsolete or disproven hypothesis notes when they no longer help the investigation
 </instructions>
 
 <recommended_usage>
@@ -731,6 +732,145 @@ Use to delete test or scratch notes created during experimentation
 
 export type DeleteNoteToolInput = z.infer<typeof deleteNoteToolInputSchema>;
 
+const findingRequiredText = (label: string, max: number) =>
+  z
+    .string()
+    .trim()
+    .min(1, `${label} is required`)
+    .max(max, `${label} must be ${max.toLocaleString()} characters or fewer`);
+
+const findingOptionalText = (label: string, max: number) =>
+  findingRequiredText(label, max).optional();
+
+const findingCodeLocationSchema = z
+  .object({
+    file: findingRequiredText("File", 500).refine((path) => {
+      const segments = path.split("/");
+      return !(
+        path.startsWith("/") ||
+        path.startsWith("./") ||
+        /^[A-Za-z]:/.test(path) ||
+        path.includes("\\") ||
+        path.includes("\0") ||
+        segments.some((segment) => segment === ".." || segment === "")
+      );
+    }, "File must be a relative repository path without traversal, empty segments, or backslashes"),
+    start_line: z.number().int().positive(),
+    end_line: z.number().int().positive(),
+    snippet: findingOptionalText("Snippet", 16_000),
+    label: findingOptionalText("Label", 200),
+    fix_before: findingOptionalText("Fix before", 16_000),
+    fix_after: findingOptionalText("Fix after", 16_000),
+  })
+  .strict()
+  .superRefine((location, ctx) => {
+    if (location.end_line < location.start_line) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["end_line"],
+        message: "End line must be greater than or equal to start line",
+      });
+    }
+    if (Boolean(location.fix_before) !== Boolean(location.fix_after)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [location.fix_before ? "fix_after" : "fix_before"],
+        message: "fix_before and fix_after must be provided together",
+      });
+    }
+  });
+
+export const createVulnerabilityReportToolInputSchema = z
+  .object({
+    title: findingRequiredText("Title", 200),
+    description: findingRequiredText("Description", 4_000),
+    impact: findingRequiredText("Impact", 4_000),
+    target: findingRequiredText("Target", 1_000),
+    technical_analysis: findingRequiredText("Technical analysis", 12_000),
+    poc_description: findingRequiredText("PoC description", 8_000),
+    poc_script_code: findingRequiredText("PoC script/code", 32_000),
+    remediation_steps: findingRequiredText("Remediation steps", 8_000),
+    evidence: findingRequiredText("Evidence", 16_000),
+    assumptions: findingRequiredText("Assumptions", 4_000),
+    fix_effort: z.enum(["trivial", "low", "medium", "high"]),
+    cvss_breakdown: z
+      .object({
+        attack_vector: z.enum(["N", "A", "L", "P"]),
+        attack_complexity: z.enum(["L", "H"]),
+        privileges_required: z.enum(["N", "L", "H"]),
+        user_interaction: z.enum(["N", "R"]),
+        scope: z.enum(["U", "C"]),
+        confidentiality: z.enum(["N", "L", "H"]),
+        integrity: z.enum(["N", "L", "H"]),
+        availability: z.enum(["N", "L", "H"]),
+      })
+      .strict(),
+    endpoint: findingOptionalText("Endpoint", 1_000),
+    method: findingOptionalText("Method", 32),
+    cve: z
+      .string()
+      .trim()
+      .regex(/^CVE-\d{4}-\d{4,}$/, "CVE must use CVE-YYYY-NNNN format")
+      .max(32)
+      .optional(),
+    cwe: z
+      .string()
+      .trim()
+      .regex(/^CWE-\d+$/, "CWE must use CWE-NNN format")
+      .max(24)
+      .optional(),
+    code_locations: z.array(findingCodeLocationSchema).max(50).optional(),
+  })
+  .strict()
+  .superRefine((input, ctx) => {
+    const payloadBytes = new TextEncoder().encode(JSON.stringify(input)).length;
+    if (payloadBytes > 128 * 1024) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Finding payload must be 131072 bytes or smaller",
+      });
+    }
+  });
+
+export type CreateVulnerabilityReportInput = z.infer<
+  typeof createVulnerabilityReportToolInputSchema
+>;
+
+export const createVulnerabilityReportTool = tool({
+  description: `Persist one fully confirmed vulnerability as a structured finding.
+
+<when_to_use>
+Use this tool only after all of the following are true:
+- The issue is a concrete vulnerability on a specific target
+- Concrete evidence demonstrates the vulnerable behavior
+- The issue can be reproduced reliably
+- A working proof of concept is available in poc_script_code
+- Impact and exploitability prerequisites are understood
+</when_to_use>
+
+<when_not_to_use>
+- Scanner output, suspicious behavior, or an unverified idea
+- A hypothesis without demonstrated impact or a working PoC
+- General hardening advice, informational observations, or methodology notes
+- Dependency-only vulnerability reports based only on a published advisory
+- A vulnerability already reported in this source chat
+</when_not_to_use>
+
+<instructions>
+- Call this tool exactly once after a vulnerability becomes confirmed
+- File one distinct root cause per call; do not combine unrelated vulnerabilities
+- Do not retry a duplicate response
+- Use formal, objective, vendor-neutral markdown in the report fields
+- Put reproduction steps in poc_description and executable exploit/payload code in poc_script_code
+- Put concrete requests, responses, observed behavior, logs, or code proof in evidence
+- Populate code_locations whenever source code is available
+- Pass bare CVE/CWE identifiers only when certain
+- CVSS 3.1 must include all eight base metrics; the server calculates the score and severity
+- Do not mention internal agents, models, prompts, sandboxes, report IDs, or tester-only paths in report content
+</instructions>`,
+  inputSchema: createVulnerabilityReportToolInputSchema,
+});
+
 export type AgentToolSchemaMode = "agent" | "ask";
 
 export const createAgentToolSchemaSet = ({
@@ -775,6 +915,9 @@ export const createAgentToolSchemaSet = ({
     get_terminal_files: getTerminalFilesTool,
     file: createFileToolSchema({ supportsView: supportsFileView }),
     todo_write: todoWriteTool,
+    ...(!isTemporary && {
+      create_vulnerability_report: createVulnerabilityReportTool,
+    }),
     ...notes,
     ...networkTools,
   };
diff --git a/lib/api/__tests__/agent-long-contracts.test.ts b/lib/api/__tests__/agent-long-contracts.test.ts
index 811e82529..f8e3884e0 100644
--- a/lib/api/__tests__/agent-long-contracts.test.ts
+++ b/lib/api/__tests__/agent-long-contracts.test.ts
@@ -142,6 +142,11 @@ const toolSchemasSrc = fs.readFileSync(
   "utf8",
 );
 
+const toolIndexSrc = fs.readFileSync(
+  path.resolve(__dirname, "../../ai/tools/index.ts"),
+  "utf8",
+);
+
 const toolExecutionSources = [
   {
     src: fs.readFileSync(
@@ -204,6 +209,13 @@ const toolExecutionSources = [
       "deleteNoteTool",
     ],
   },
+  {
+    src: fs.readFileSync(
+      path.resolve(__dirname, "../../ai/tools/findings.ts"),
+      "utf8",
+    ),
+    schemaNames: ["createVulnerabilityReportTool"],
+  },
 ];
 
 describe("agent tool schemas — Head Start bundle boundary", () => {
@@ -232,6 +244,9 @@ describe("agent tool schemas — Head Start bundle boundary", () => {
     );
     expect(toolSchemasSrc).toMatch(/todo_write:\s*todoWriteTool/);
     expect(toolSchemasSrc).toMatch(/create_note:\s*createNoteTool/);
+    expect(toolSchemasSrc).toMatch(
+      /create_vulnerability_report:\s*createVulnerabilityReportTool/,
+    );
     expect(toolSchemasSrc).toMatch(/web_search:\s*webSearchTool/);
     expect(toolSchemasSrc).toMatch(/open_url:\s*openUrlTool/);
     expect(toolSchemasSrc).toMatch(/if\s*\(\s*mode\s*===\s*"ask"\s*\)/);
@@ -245,6 +260,16 @@ describe("agent tool schemas — Head Start bundle boundary", () => {
       expect(src).toMatch(/\bexecute\s*:/);
     }
   });
+
+  test("normal and durable Agent share one persistent-only finding tool factory", () => {
+    expect(chatHandlerSrc).toMatch(/createTools\(/);
+    expect(taskSrc).toMatch(/createTools\(/);
+    expect(toolIndexSrc).toMatch(
+      /create_vulnerability_report:\s*createCreateVulnerabilityReport\(context\)/,
+    );
+    expect(toolIndexSrc).toMatch(/return\s+mode\s*===\s*"ask"/);
+    expect(toolIndexSrc).toMatch(/\.\.\.\(!isTemporary\s*&&\s*\{/);
+  });
 });
 
 describe("agent-long-transport — direct UI stream reader", () => {
diff --git a/lib/chat/chat-processor.ts b/lib/chat/chat-processor.ts
index cd4f317df..d69fa56f1 100644
--- a/lib/chat/chat-processor.ts
+++ b/lib/chat/chat-processor.ts
@@ -201,6 +201,7 @@ const ABORT_RENDERABLE_TOOL_TYPES = new Set([
   "tool-list_notes",
   "tool-update_note",
   "tool-delete_note",
+  "tool-create_vulnerability_report",
   "tool-list_requests",
   "tool-view_request",
   "tool-send_request",
@@ -655,7 +656,10 @@ function stripProviderMetadata(messages: UIMessage[]): UIMessage[] {
 }
 
 // UI-only part types that should not be sent to AI providers
-const UI_ONLY_PART_TYPES = new Set(["data-summarization"]);
+const UI_ONLY_PART_TYPES = new Set([
+  "data-summarization",
+  "data-shared-finding",
+]);
 
 /**
  * Filters out UI-only parts from a message that AI providers don't understand.
diff --git a/lib/chat/compaction/__tests__/prune-tool-outputs.test.ts b/lib/chat/compaction/__tests__/prune-tool-outputs.test.ts
index d2bca54cd..1552ff382 100644
--- a/lib/chat/compaction/__tests__/prune-tool-outputs.test.ts
+++ b/lib/chat/compaction/__tests__/prune-tool-outputs.test.ts
@@ -565,12 +565,13 @@ describe("pruneToolOutputs", () => {
     );
   });
 
-  it("never prunes protected tools (create_note, list_notes, update_note, delete_note)", () => {
+  it("never prunes protected state tools, including structured findings", () => {
     const protectedTools = [
       "create_note",
       "list_notes",
       "update_note",
       "delete_note",
+      "create_vulnerability_report",
     ];
 
     for (const toolName of protectedTools) {
diff --git a/lib/chat/compaction/prune-tool-outputs.ts b/lib/chat/compaction/prune-tool-outputs.ts
index ace1c00ef..2cbd47de6 100644
--- a/lib/chat/compaction/prune-tool-outputs.ts
+++ b/lib/chat/compaction/prune-tool-outputs.ts
@@ -28,6 +28,7 @@ const PROTECTED_TOOLS = new Set([
   "list_notes",
   "update_note",
   "delete_note",
+  "create_vulnerability_report",
 ]);
 
 const TOOL_TYPE_PREFIX = "tool-";
diff --git a/lib/db/actions.ts b/lib/db/actions.ts
index 41003ecd1..809e3fc01 100644
--- a/lib/db/actions.ts
+++ b/lib/db/actions.ts
@@ -22,6 +22,7 @@ import type {
   SubscriptionTier,
   NoteCategory,
 } from "@/types";
+import type { CreateVulnerabilityReportInput } from "@/lib/findings/validation";
 import type { Id } from "@/convex/_generated/dataModel";
 import { v4 as uuidv4 } from "uuid";
 import { AGENT_RESUME_PREAMBLE } from "@/lib/chat/summarization/prompts";
@@ -1849,6 +1850,45 @@ export async function getLatestSummary({ chatId }: { chatId: string }) {
   }
 }
 
+// ============================================================================
+// Findings Actions
+// ============================================================================
+
+export async function createFinding({
+  userId,
+  chatId,
+  messageId,
+  toolCallId,
+  report,
+}: {
+  userId: string;
+  chatId: string;
+  messageId: string;
+  toolCallId: string;
+  report: CreateVulnerabilityReportInput;
+}) {
+  try {
+    return await getConvexClient().mutation(
+      api.findings.createFindingForBackend,
+      {
+        serviceKey,
+        userId,
+        chatId,
+        messageId,
+        toolCallId,
+        report,
+      },
+    );
+  } catch (error) {
+    throw databaseError("findings.createFindingForBackend", error, {
+      user_id: userId,
+      chat_id: chatId,
+      message_id: messageId,
+      tool_call_id: toolCallId,
+    });
+  }
+}
+
 // ============================================================================
 // Notes Actions
 // ============================================================================
diff --git a/lib/findings/__tests__/cvss31.test.ts b/lib/findings/__tests__/cvss31.test.ts
new file mode 100644
index 000000000..0caab9b5b
--- /dev/null
+++ b/lib/findings/__tests__/cvss31.test.ts
@@ -0,0 +1,132 @@
+import {
+  calculateCvss31,
+  calculateCvss31BaseScore,
+  getCvss31Severity,
+  getCvss31Vector,
+  type Cvss31Breakdown,
+} from "../cvss31";
+
+describe("CVSS 3.1 base scoring", () => {
+  test.each<{
+    vector: Cvss31Breakdown;
+    score: number;
+  }>([
+    {
+      vector: {
+        attack_vector: "N",
+        attack_complexity: "L",
+        privileges_required: "N",
+        user_interaction: "N",
+        scope: "U",
+        confidentiality: "H",
+        integrity: "H",
+        availability: "H",
+      },
+      score: 9.8,
+    },
+    {
+      vector: {
+        attack_vector: "N",
+        attack_complexity: "L",
+        privileges_required: "N",
+        user_interaction: "N",
+        scope: "U",
+        confidentiality: "H",
+        integrity: "N",
+        availability: "N",
+      },
+      score: 7.5,
+    },
+    {
+      vector: {
+        attack_vector: "N",
+        attack_complexity: "L",
+        privileges_required: "N",
+        user_interaction: "R",
+        scope: "C",
+        confidentiality: "L",
+        integrity: "L",
+        availability: "N",
+      },
+      score: 6.1,
+    },
+    {
+      vector: {
+        attack_vector: "L",
+        attack_complexity: "L",
+        privileges_required: "H",
+        user_interaction: "N",
+        scope: "U",
+        confidentiality: "L",
+        integrity: "L",
+        availability: "L",
+      },
+      score: 4.2,
+    },
+  ])("matches FIRST vector score $score", ({ vector, score }) => {
+    expect(calculateCvss31BaseScore(vector)).toBe(score);
+  });
+
+  it("rounds up to one decimal instead of rounding to nearest", () => {
+    const vector: Cvss31Breakdown = {
+      attack_vector: "N",
+      attack_complexity: "L",
+      privileges_required: "N",
+      user_interaction: "R",
+      scope: "C",
+      confidentiality: "L",
+      integrity: "L",
+      availability: "N",
+    };
+
+    expect(calculateCvss31BaseScore(vector)).toBe(6.1);
+  });
+
+  it("returns zero when all impact metrics are none", () => {
+    const result = calculateCvss31({
+      attack_vector: "N",
+      attack_complexity: "L",
+      privileges_required: "N",
+      user_interaction: "N",
+      scope: "U",
+      confidentiality: "N",
+      integrity: "N",
+      availability: "N",
+    });
+
+    expect(result).toEqual({
+      score: 0,
+      severity: "info",
+      vector: "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:N",
+    });
+  });
+
+  it("serializes metrics in canonical CVSS 3.1 order", () => {
+    expect(
+      getCvss31Vector({
+        attack_vector: "A",
+        attack_complexity: "H",
+        privileges_required: "L",
+        user_interaction: "R",
+        scope: "C",
+        confidentiality: "L",
+        integrity: "H",
+        availability: "N",
+      }),
+    ).toBe("CVSS:3.1/AV:A/AC:H/PR:L/UI:R/S:C/C:L/I:H/A:N");
+  });
+
+  test.each([
+    [0, "info"],
+    [0.1, "low"],
+    [3.9, "low"],
+    [4, "medium"],
+    [6.9, "medium"],
+    [7, "high"],
+    [8.9, "high"],
+    [9, "critical"],
+    [10, "critical"],
+  ] as const)("maps %s to %s", (score, severity) => {
+    expect(getCvss31Severity(score)).toBe(severity);
+  });
+});
diff --git a/lib/findings/__tests__/share-sanitizer.test.ts b/lib/findings/__tests__/share-sanitizer.test.ts
new file mode 100644
index 000000000..343407c1a
--- /dev/null
+++ b/lib/findings/__tests__/share-sanitizer.test.ts
@@ -0,0 +1,92 @@
+import { sanitizeFindingPartsForShare } from "../share-sanitizer";
+
+const privateInput = {
+  title: "Cross-tenant invoice access",
+  target: "app.example.test",
+  evidence: "secret response body",
+  technical_analysis: "private source analysis",
+  poc_script_code: "curl secret",
+  cve: "CVE-2026-12345",
+  cwe: "CWE-639",
+  code_locations: [{ file: "secret.ts", start_line: 1, end_line: 2 }],
+};
+
+describe("public finding sanitizer", () => {
+  it("replaces a successful tool part with compact safe metadata", () => {
+    const [part] = sanitizeFindingPartsForShare([
+      {
+        type: "tool-create_vulnerability_report",
+        toolCallId: "private-tool-id",
+        state: "output-available",
+        input: privateInput,
+        output: {
+          success: true,
+          finding_id: "private-finding-id",
+          title: privateInput.title,
+          target: privateInput.target,
+          endpoint: "/api/invoices/123",
+          severity: "high",
+          cvss_score: 8.1,
+        },
+      },
+    ]);
+
+    expect(part).toEqual({
+      type: "data-shared-finding",
+      data: {
+        title: privateInput.title,
+        target: privateInput.target,
+        severity: "high",
+        cvss_score: 8.1,
+      },
+    });
+    expect(JSON.stringify(part)).not.toMatch(
+      /private-tool-id|private-finding-id|secret|evidence|technical_analysis|poc|code_locations|CVE|CWE|endpoint/,
+    );
+  });
+
+  it("drops failed, streaming, and dynamic finding tool parts", () => {
+    expect(
+      sanitizeFindingPartsForShare([
+        {
+          type: "tool-create_vulnerability_report",
+          state: "output-available",
+          input: privateInput,
+          output: { success: false, error: "validation" },
+        },
+        {
+          type: "tool-create_vulnerability_report",
+          state: "input-available",
+          input: privateInput,
+        },
+        {
+          type: "dynamic-tool",
+          toolName: "create_vulnerability_report",
+          input: privateInput,
+        },
+      ]),
+    ).toEqual([]);
+  });
+
+  it("never falls back to private input when compact output metadata is missing", () => {
+    expect(
+      sanitizeFindingPartsForShare([
+        {
+          type: "tool-create_vulnerability_report",
+          state: "output-available",
+          input: privateInput,
+          output: {
+            success: true,
+            severity: "high",
+            cvss_score: 8.1,
+          },
+        },
+      ]),
+    ).toEqual([]);
+  });
+
+  it("preserves unrelated message parts", () => {
+    const text = { type: "text", text: "Public explanation" };
+    expect(sanitizeFindingPartsForShare([text])).toEqual([text]);
+  });
+});
diff --git a/lib/findings/__tests__/validation.test.ts b/lib/findings/__tests__/validation.test.ts
new file mode 100644
index 000000000..875285e62
--- /dev/null
+++ b/lib/findings/__tests__/validation.test.ts
@@ -0,0 +1,209 @@
+import {
+  createFindingDedupeKey,
+  createFindingSearchText,
+  createVulnerabilityReportInputSchema,
+  type CreateVulnerabilityReportInput,
+} from "../validation";
+
+const validReport = (): CreateVulnerabilityReportInput => ({
+  title: "Cross-tenant invoice access",
+  description: "An authenticated user can read another user's invoice.",
+  impact: "A user can disclose another customer's billing address.",
+  target: "https://app.example.test",
+  endpoint: "/api/invoices/:id",
+  method: "GET",
+  cve: "CVE-2026-12345",
+  cwe: "CWE-639",
+  technical_analysis: "The handler loads by invoice id without an owner check.",
+  poc_description: "Sign in as user A and request user B's invoice id.",
+  poc_script_code:
+    "curl -H 'Authorization: Bearer user-a' /api/invoices/user-b",
+  remediation_steps: "Scope the invoice query to the authenticated account.",
+  evidence: "The response returned HTTP 200 and user B's billing address.",
+  assumptions: "Both accounts are ordinary customer accounts.",
+  fix_effort: "low",
+  cvss_breakdown: {
+    attack_vector: "N",
+    attack_complexity: "L",
+    privileges_required: "L",
+    user_interaction: "N",
+    scope: "U",
+    confidentiality: "H",
+    integrity: "N",
+    availability: "N",
+  },
+  code_locations: [
+    {
+      file: "app/api/invoices/[id]/route.ts",
+      start_line: 20,
+      end_line: 32,
+      snippet: "db.invoice.findUnique({ where: { id } })",
+      label: "Missing owner predicate",
+      fix_before: "where: { id }",
+      fix_after: "where: { id, userId }",
+    },
+  ],
+});
+
+describe("structured finding validation", () => {
+  it("accepts a complete report", () => {
+    expect(createVulnerabilityReportInputSchema.parse(validReport())).toEqual(
+      validReport(),
+    );
+  });
+
+  test.each([
+    "title",
+    "description",
+    "impact",
+    "target",
+    "technical_analysis",
+    "poc_description",
+    "poc_script_code",
+    "remediation_steps",
+    "evidence",
+    "assumptions",
+    "fix_effort",
+    "cvss_breakdown",
+  ] as const)("requires %s", (field) => {
+    const report = validReport() as Record<string, unknown>;
+    delete report[field];
+    expect(createVulnerabilityReportInputSchema.safeParse(report).success).toBe(
+      false,
+    );
+  });
+
+  test.each([
+    "attack_vector",
+    "attack_complexity",
+    "privileges_required",
+    "user_interaction",
+    "scope",
+    "confidentiality",
+    "integrity",
+    "availability",
+  ] as const)("requires CVSS metric %s", (metric) => {
+    const report = validReport() as any;
+    delete report.cvss_breakdown[metric];
+    expect(createVulnerabilityReportInputSchema.safeParse(report).success).toBe(
+      false,
+    );
+  });
+
+  test.each([
+    ["cve", "2026-1234"],
+    ["cve", "CVE-26-1234"],
+    ["cwe", "639"],
+    ["cwe", "CWE-name"],
+  ])("rejects invalid %s format", (field, value) => {
+    expect(
+      createVulnerabilityReportInputSchema.safeParse({
+        ...validReport(),
+        [field]: value,
+      }).success,
+    ).toBe(false);
+  });
+
+  test.each([
+    "/etc/passwd",
+    "../secret.ts",
+    "src/../../secret.ts",
+    "src\\secret.ts",
+    "C:/secret.ts",
+    "src//secret.ts",
+  ])("rejects unsafe code path %s", (file) => {
+    expect(
+      createVulnerabilityReportInputSchema.safeParse({
+        ...validReport(),
+        code_locations: [{ file, start_line: 1, end_line: 1 }],
+      }).success,
+    ).toBe(false);
+  });
+
+  it("rejects non-positive and reversed line ranges", () => {
+    for (const location of [
+      { file: "src/a.ts", start_line: 0, end_line: 1 },
+      { file: "src/a.ts", start_line: 4, end_line: 3 },
+    ]) {
+      expect(
+        createVulnerabilityReportInputSchema.safeParse({
+          ...validReport(),
+          code_locations: [location],
+        }).success,
+      ).toBe(false);
+    }
+  });
+
+  it("requires fix_before and fix_after together", () => {
+    expect(
+      createVulnerabilityReportInputSchema.safeParse({
+        ...validReport(),
+        code_locations: [
+          {
+            file: "src/a.ts",
+            start_line: 1,
+            end_line: 1,
+            fix_before: "unsafe()",
+          },
+        ],
+      }).success,
+    ).toBe(false);
+  });
+
+  it("rejects empty required text after trimming", () => {
+    expect(
+      createVulnerabilityReportInputSchema.safeParse({
+        ...validReport(),
+        evidence: "   ",
+      }).success,
+    ).toBe(false);
+  });
+
+  it("rejects a report above the total payload limit", () => {
+    const code_locations = Array.from({ length: 10 }, (_, index) => ({
+      file: `src/file-${index}.ts`,
+      start_line: 1,
+      end_line: 2,
+      snippet: "x".repeat(15_000),
+    }));
+
+    const result = createVulnerabilityReportInputSchema.safeParse({
+      ...validReport(),
+      code_locations,
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            message: expect.stringContaining("131072 bytes"),
+          }),
+        ]),
+      );
+    }
+  });
+
+  it("normalizes same-chat fingerprint fields deterministically", () => {
+    const first = validReport();
+    const second = {
+      ...first,
+      title: "  CROSS-TENANT   invoice access ",
+      target: "HTTPS://APP.EXAMPLE.TEST",
+      method: "get",
+      cwe: "cwe-639",
+    };
+
+    expect(createFindingDedupeKey(first)).toBe(createFindingDedupeKey(second));
+  });
+
+  it("indexes only the approved searchable metadata", () => {
+    const report = validReport();
+    const searchText = createFindingSearchText(report);
+    expect(searchText).toContain(report.title);
+    expect(searchText).toContain(report.target);
+    expect(searchText).toContain(report.endpoint);
+    expect(searchText).toContain(report.cve);
+    expect(searchText).toContain(report.cwe);
+    expect(searchText).not.toContain(report.evidence);
+  });
+});
diff --git a/lib/findings/cvss31.ts b/lib/findings/cvss31.ts
new file mode 100644
index 000000000..5c8516e04
--- /dev/null
+++ b/lib/findings/cvss31.ts
@@ -0,0 +1,90 @@
+export const CVSS31_METRIC_VALUES = {
+  attack_vector: ["N", "A", "L", "P"],
+  attack_complexity: ["L", "H"],
+  privileges_required: ["N", "L", "H"],
+  user_interaction: ["N", "R"],
+  scope: ["U", "C"],
+  confidentiality: ["N", "L", "H"],
+  integrity: ["N", "L", "H"],
+  availability: ["N", "L", "H"],
+} as const;
+
+export type Cvss31Breakdown = {
+  [
+    K in keyof typeof CVSS31_METRIC_VALUES
+  ]: (typeof CVSS31_METRIC_VALUES)[K][number];
+};
+
+export type FindingSeverity = "critical" | "high" | "medium" | "low" | "info";
+
+const WEIGHTS = {
+  attack_vector: { N: 0.85, A: 0.62, L: 0.55, P: 0.2 },
+  attack_complexity: { L: 0.77, H: 0.44 },
+  user_interaction: { N: 0.85, R: 0.62 },
+  confidentiality: { N: 0, L: 0.22, H: 0.56 },
+  integrity: { N: 0, L: 0.22, H: 0.56 },
+  availability: { N: 0, L: 0.22, H: 0.56 },
+  privileges_required: {
+    U: { N: 0.85, L: 0.62, H: 0.27 },
+    C: { N: 0.85, L: 0.68, H: 0.5 },
+  },
+} as const;
+
+const roundUpToOneDecimal = (value: number): number => {
+  const fiveDecimalInteger = Math.round(value * 100_000);
+  if (fiveDecimalInteger % 10_000 === 0) {
+    return fiveDecimalInteger / 100_000;
+  }
+  return (Math.floor(fiveDecimalInteger / 10_000) + 1) / 10;
+};
+
+export const getCvss31Severity = (score: number): FindingSeverity => {
+  if (score >= 9) return "critical";
+  if (score >= 7) return "high";
+  if (score >= 4) return "medium";
+  if (score > 0) return "low";
+  return "info";
+};
+
+export const getCvss31Vector = (metrics: Cvss31Breakdown): string =>
+  `CVSS:3.1/AV:${metrics.attack_vector}/AC:${metrics.attack_complexity}/PR:${metrics.privileges_required}/UI:${metrics.user_interaction}/S:${metrics.scope}/C:${metrics.confidentiality}/I:${metrics.integrity}/A:${metrics.availability}`;
+
+export const calculateCvss31BaseScore = (metrics: Cvss31Breakdown): number => {
+  const scope = metrics.scope;
+  const impactSubScore =
+    1 -
+    (1 - WEIGHTS.confidentiality[metrics.confidentiality]) *
+      (1 - WEIGHTS.integrity[metrics.integrity]) *
+      (1 - WEIGHTS.availability[metrics.availability]);
+
+  const impact =
+    scope === "U"
+      ? 6.42 * impactSubScore
+      : 7.52 * (impactSubScore - 0.029) -
+        3.25 * Math.pow(impactSubScore - 0.02, 15);
+
+  if (impact <= 0) return 0;
+
+  const exploitability =
+    8.22 *
+    WEIGHTS.attack_vector[metrics.attack_vector] *
+    WEIGHTS.attack_complexity[metrics.attack_complexity] *
+    WEIGHTS.privileges_required[scope][metrics.privileges_required] *
+    WEIGHTS.user_interaction[metrics.user_interaction];
+
+  const capped =
+    scope === "U"
+      ? Math.min(impact + exploitability, 10)
+      : Math.min(1.08 * (impact + exploitability), 10);
+
+  return roundUpToOneDecimal(capped);
+};
+
+export const calculateCvss31 = (metrics: Cvss31Breakdown) => {
+  const score = calculateCvss31BaseScore(metrics);
+  return {
+    score,
+    severity: getCvss31Severity(score),
+    vector: getCvss31Vector(metrics),
+  };
+};
diff --git a/lib/findings/share-sanitizer.ts b/lib/findings/share-sanitizer.ts
new file mode 100644
index 000000000..37486ae35
--- /dev/null
+++ b/lib/findings/share-sanitizer.ts
@@ -0,0 +1,59 @@
+type SharedFindingPart = {
+  type: "data-shared-finding";
+  data: {
+    title: string;
+    target: string;
+    severity: "critical" | "high" | "medium" | "low" | "info";
+    cvss_score: number;
+  };
+};
+
+const VALID_SEVERITIES = new Set(["critical", "high", "medium", "low", "info"]);
+
+const sanitizeFindingToolPart = (part: any): SharedFindingPart | null => {
+  const output = part?.output?.result ?? part?.output;
+  if (output?.success !== true) return null;
+
+  const title = output.title;
+  const target = output.target;
+  const severity = output.severity;
+  const cvssScore = output.cvss_score;
+
+  if (
+    typeof title !== "string" ||
+    title.trim().length === 0 ||
+    typeof target !== "string" ||
+    target.trim().length === 0 ||
+    typeof severity !== "string" ||
+    !VALID_SEVERITIES.has(severity) ||
+    typeof cvssScore !== "number" ||
+    !Number.isFinite(cvssScore) ||
+    cvssScore < 0 ||
+    cvssScore > 10
+  ) {
+    return null;
+  }
+
+  return {
+    type: "data-shared-finding",
+    data: {
+      title: title.slice(0, 200),
+      target: target.slice(0, 1_000),
+      severity: severity as SharedFindingPart["data"]["severity"],
+      cvss_score: cvssScore,
+    },
+  };
+};
+
+export const sanitizeFindingPartsForShare = (parts: any[]): any[] =>
+  parts.flatMap((part) => {
+    if (
+      part?.type === "dynamic-tool" &&
+      part?.toolName === "create_vulnerability_report"
+    ) {
+      return [];
+    }
+    if (part?.type !== "tool-create_vulnerability_report") return [part];
+    const safePart = sanitizeFindingToolPart(part);
+    return safePart ? [safePart] : [];
+  });
diff --git a/lib/findings/validation.ts b/lib/findings/validation.ts
new file mode 100644
index 000000000..40e97c478
--- /dev/null
+++ b/lib/findings/validation.ts
@@ -0,0 +1,161 @@
+import { z } from "zod";
+import { CVSS31_METRIC_VALUES } from "./cvss31";
+
+export const FINDING_PAYLOAD_MAX_BYTES = 128 * 1024;
+export const FINDING_CODE_LOCATIONS_MAX = 50;
+
+const requiredText = (label: string, max: number) =>
+  z
+    .string()
+    .trim()
+    .min(1, `${label} is required`)
+    .max(max, `${label} must be ${max.toLocaleString()} characters or fewer`);
+
+const optionalText = (label: string, max: number) =>
+  z
+    .string()
+    .trim()
+    .min(1, `${label} cannot be empty`)
+    .max(max, `${label} must be ${max.toLocaleString()} characters or fewer`)
+    .optional();
+
+const relativeCodePathSchema = requiredText("File", 500).superRefine(
+  (path, ctx) => {
+    const segments = path.split("/");
+    if (
+      path.startsWith("/") ||
+      path.startsWith("./") ||
+      /^[A-Za-z]:/.test(path) ||
+      path.includes("\\") ||
+      path.includes("\0") ||
+      segments.some((segment) => segment === ".." || segment === "")
+    ) {
+      ctx.addIssue({
+        code: "custom",
+        message:
+          "File must be a relative repository path without traversal, empty segments, or backslashes",
+      });
+    }
+  },
+);
+
+export const findingCodeLocationSchema = z
+  .object({
+    file: relativeCodePathSchema,
+    start_line: z.number().int().positive(),
+    end_line: z.number().int().positive(),
+    snippet: optionalText("Snippet", 16_000),
+    label: optionalText("Label", 200),
+    fix_before: optionalText("Fix before", 16_000),
+    fix_after: optionalText("Fix after", 16_000),
+  })
+  .strict()
+  .superRefine((location, ctx) => {
+    if (location.end_line < location.start_line) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["end_line"],
+        message: "End line must be greater than or equal to start line",
+      });
+    }
+    if (Boolean(location.fix_before) !== Boolean(location.fix_after)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [location.fix_before ? "fix_after" : "fix_before"],
+        message: "fix_before and fix_after must be provided together",
+      });
+    }
+  });
+
+export const cvss31BreakdownSchema = z
+  .object({
+    attack_vector: z.enum(CVSS31_METRIC_VALUES.attack_vector),
+    attack_complexity: z.enum(CVSS31_METRIC_VALUES.attack_complexity),
+    privileges_required: z.enum(CVSS31_METRIC_VALUES.privileges_required),
+    user_interaction: z.enum(CVSS31_METRIC_VALUES.user_interaction),
+    scope: z.enum(CVSS31_METRIC_VALUES.scope),
+    confidentiality: z.enum(CVSS31_METRIC_VALUES.confidentiality),
+    integrity: z.enum(CVSS31_METRIC_VALUES.integrity),
+    availability: z.enum(CVSS31_METRIC_VALUES.availability),
+  })
+  .strict();
+
+export const createVulnerabilityReportInputSchema = z
+  .object({
+    title: requiredText("Title", 200),
+    description: requiredText("Description", 4_000),
+    impact: requiredText("Impact", 4_000),
+    target: requiredText("Target", 1_000),
+    technical_analysis: requiredText("Technical analysis", 12_000),
+    poc_description: requiredText("PoC description", 8_000),
+    poc_script_code: requiredText("PoC script/code", 32_000),
+    remediation_steps: requiredText("Remediation steps", 8_000),
+    evidence: requiredText("Evidence", 16_000),
+    assumptions: requiredText("Assumptions", 4_000),
+    fix_effort: z.enum(["trivial", "low", "medium", "high"]),
+    cvss_breakdown: cvss31BreakdownSchema,
+    endpoint: optionalText("Endpoint", 1_000),
+    method: optionalText("Method", 32),
+    cve: z
+      .string()
+      .trim()
+      .regex(/^CVE-\d{4}-\d{4,}$/, "CVE must use CVE-YYYY-NNNN format")
+      .max(32)
+      .optional(),
+    cwe: z
+      .string()
+      .trim()
+      .regex(/^CWE-\d+$/, "CWE must use CWE-NNN format")
+      .max(24)
+      .optional(),
+    code_locations: z
+      .array(findingCodeLocationSchema)
+      .max(
+        FINDING_CODE_LOCATIONS_MAX,
+        `Code locations are limited to ${FINDING_CODE_LOCATIONS_MAX}`,
+      )
+      .optional(),
+  })
+  .strict()
+  .superRefine((input, ctx) => {
+    const payloadBytes = new TextEncoder().encode(JSON.stringify(input)).length;
+    if (payloadBytes > FINDING_PAYLOAD_MAX_BYTES) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Finding payload must be ${FINDING_PAYLOAD_MAX_BYTES} bytes or smaller`,
+      });
+    }
+  });
+
+export type CreateVulnerabilityReportInput = z.infer<
+  typeof createVulnerabilityReportInputSchema
+>;
+export type FindingCodeLocation = z.infer<typeof findingCodeLocationSchema>;
+
+const normalizeFingerprintValue = (value: string | undefined): string =>
+  (value ?? "").normalize("NFKC").trim().toLowerCase().replace(/\s+/g, " ");
+
+export const createFindingDedupeKey = (
+  input: Pick<
+    CreateVulnerabilityReportInput,
+    "target" | "endpoint" | "method" | "cwe" | "title"
+  >,
+): string =>
+  JSON.stringify([
+    normalizeFingerprintValue(input.target),
+    normalizeFingerprintValue(input.endpoint),
+    normalizeFingerprintValue(input.method),
+    normalizeFingerprintValue(input.cwe),
+    normalizeFingerprintValue(input.title),
+  ]);
+
+export const createFindingSearchText = (
+  input: Pick<
+    CreateVulnerabilityReportInput,
+    "title" | "target" | "endpoint" | "cve" | "cwe"
+  >,
+): string =>
+  [input.title, input.target, input.endpoint, input.cve, input.cwe]
+    .filter((value): value is string => Boolean(value))
+    .join(" \n")
+    .slice(0, 4_000);
diff --git a/lib/system-prompt.ts b/lib/system-prompt.ts
index 1064b7197..1a69e53ed 100644
--- a/lib/system-prompt.ts
+++ b/lib/system-prompt.ts
@@ -207,6 +207,7 @@ const getAgentModeSection = (
   mode: ChatMode,
   sandboxContext?: string | null,
   agentPermissionMode: AgentPermissionMode = "full_access",
+  isTemporary: boolean = false,
 ): string => {
   const agentSpecificNote =
     mode === "agent"
@@ -317,10 +318,15 @@ When running security scans:
 
 <finding_quality>
 Treat scanner output, tool hits, and suspicious behavior as leads until validated with evidence.
-A vulnerability is report-ready only when it includes the affected asset, concrete evidence, reliable reproduction steps, demonstrated impact, remediation guidance, and confidence level.
+A vulnerability is report-ready only when it includes the affected asset, concrete evidence, reliable reproduction steps, a working proof of concept, demonstrated impact, remediation guidance, and understood exploitability prerequisites.
 Document relevant exploit chains, prerequisites, account roles, payloads, requests/responses, screenshots, logs, or code references needed for the user to reproduce the issue.
-Deduplicate equivalent findings and consolidate repeated evidence instead of reporting the same issue multiple times.
-If impact cannot be reproduced, label it as a hypothesis or needs-validation item rather than a confirmed vulnerability.
+${
+  isTemporary
+    ? "Temporary chats cannot persist structured findings. Keep confirmed vulnerability details in chat and do not call create_vulnerability_report."
+    : 'After all confirmation requirements are met, call create_vulnerability_report exactly once for that distinct root cause. Do not also save the confirmed vulnerability as a Notes "findings" entry, and do not retry when the tool rejects a duplicate.'
+}
+Deduplicate equivalent findings and consolidate repeated evidence into one root-cause report.
+If impact cannot be reproduced or the PoC does not work, keep it as a hypothesis or needs-validation item in chat/notes and do not call create_vulnerability_report.
 </finding_quality>
 
 ${sandboxContext ? sandboxContext : getDefaultSandboxEnvironmentSection()}
@@ -494,7 +500,12 @@ The current date is ${currentDateTime}.`;
     );
   } else {
     sections.push(
-      getAgentModeSection(mode, sandboxContext, agentPermissionMode),
+      getAgentModeSection(
+        mode,
+        sandboxContext,
+        agentPermissionMode,
+        isTemporary,
+      ),
     );
   }
 
diff --git a/lib/utils/sidebar-utils.ts b/lib/utils/sidebar-utils.ts
index 1fbb9281c..8d2bac980 100644
--- a/lib/utils/sidebar-utils.ts
+++ b/lib/utils/sidebar-utils.ts
@@ -750,6 +750,32 @@ export function extractSidebarContentFromMessage(
         modified,
       });
     }
+
+    if (
+      part.type === "tool-create_vulnerability_report" &&
+      part.state === "output-available"
+    ) {
+      const result = part.output?.result ?? part.output;
+      if (
+        result?.success === true &&
+        typeof result.finding_id === "string" &&
+        typeof result.title === "string" &&
+        typeof result.target === "string" &&
+        typeof result.severity === "string" &&
+        typeof result.cvss_score === "number"
+      ) {
+        contentList.push({
+          findingId: result.finding_id,
+          title: result.title,
+          target: result.target,
+          endpoint: result.endpoint,
+          severity: result.severity,
+          cvssScore: result.cvss_score,
+          isExecuting: false,
+          toolCallId: part.toolCallId || "",
+        });
+      }
+    }
   });
 
   return contentList;
diff --git a/types/chat.ts b/types/chat.ts
index 391059b19..a306ded77 100644
--- a/types/chat.ts
+++ b/types/chat.ts
@@ -355,12 +355,24 @@ export interface SidebarSharedFiles {
   toolCallId: string;
 }
 
+export interface SidebarFinding {
+  findingId: string;
+  title: string;
+  target: string;
+  endpoint?: string;
+  severity: "critical" | "high" | "medium" | "low" | "info";
+  cvssScore: number;
+  isExecuting: boolean;
+  toolCallId: string;
+}
+
 export type SidebarContent =
   | SidebarFile
   | SidebarTerminal
   | SidebarProxy
   | SidebarWebSearch
   | SidebarNotes
+  | SidebarFinding
   | SidebarSharedFiles;
 
 export const isSidebarFile = (
@@ -393,6 +405,12 @@ export const isSidebarNotes = (
   return "notes" in content && "action" in content;
 };
 
+export const isSidebarFinding = (
+  content: SidebarContent,
+): content is SidebarFinding => {
+  return "findingId" in content;
+};
+
 export const isSidebarSharedFiles = (
   content: SidebarContent,
 ): content is SidebarSharedFiles => {
diff --git a/types/finding.ts b/types/finding.ts
new file mode 100644
index 000000000..a5b4efd9a
--- /dev/null
+++ b/types/finding.ts
@@ -0,0 +1,41 @@
+import type { Cvss31Breakdown, FindingSeverity } from "@/lib/findings/cvss31";
+import type { FindingCodeLocation } from "@/lib/findings/validation";
+
+export type { Cvss31Breakdown, FindingSeverity, FindingCodeLocation };
+
+export interface FindingSummary {
+  finding_id: string;
+  title: string;
+  target: string;
+  endpoint?: string;
+  severity: FindingSeverity;
+  cvss_score: number;
+  chat_id: string;
+  chat_title: string;
+  created_at: number;
+}
+
+export interface FindingDetailRecord extends FindingSummary {
+  description: string;
+  impact: string;
+  technical_analysis: string;
+  poc_description: string;
+  poc_script_code: string;
+  remediation_steps: string;
+  evidence: string;
+  assumptions: string;
+  fix_effort: "trivial" | "low" | "medium" | "high";
+  cvss_breakdown: Cvss31Breakdown;
+  cvss_vector: string;
+  method?: string;
+  cve?: string;
+  cwe?: string;
+  code_locations?: FindingCodeLocation[];
+  message_id: string;
+  updated_at: number;
+}
+
+export interface FindingSourceChat {
+  chat_id: string;
+  chat_title: string;
+}
diff --git a/types/index.ts b/types/index.ts
index 499a5f8a2..de1fa2ffe 100644
--- a/types/index.ts
+++ b/types/index.ts
@@ -2,3 +2,4 @@ export * from "./chat";
 export * from "./agent";
 export * from "./file";
 export * from "./user";
+export * from "./finding";