@runfusion/fusion 0.26.0 → 0.27.1

package/dist/plugins/fusion-plugin-reports/src/dashboard/components/ReportListItem.tsx

@@ -0,0 +1,8 @@
+import type { ReportListItemVm } from "../types.js";
+
+export function ReportListItem({ report, selected, onSelect }: { report: ReportListItemVm; selected: boolean; onSelect: (id: string) => void }) {
+  return <button className="card reports-list-item" data-selected={selected ? "true" : "false"} onClick={() => onSelect(report.id)}>
+    <div className="card-header"><span className="card-title">{report.title}</span></div>
+    <div className="card-meta"><span>{report.cadence}</span><span>{report.status}</span><span>{report.periodStart} → {report.periodEnd}</span></div>
+  </button>;
+}

package/dist/plugins/fusion-plugin-reports/src/dashboard/components/ShareBlocksPanel.css

@@ -0,0 +1,29 @@
+.share-blocks-panel {
+  border-top: var(--btn-border-width) solid var(--border);
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-md);
+  padding-top: var(--space-md);
+}
+
+.share-blocks-panel__tabs {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--space-xs);
+}
+
+.share-blocks-panel__content {
+  min-height: calc(var(--space-2xl) * 4);
+  resize: vertical;
+}
+
+.share-blocks-panel__locked {
+  color: var(--text-muted);
+  margin: 0;
+}
+
+@media (max-width: 768px) {
+  .share-blocks-panel__tabs {
+    flex-direction: column;
+  }
+}

package/dist/plugins/fusion-plugin-reports/src/dashboard/components/ShareBlocksPanel.tsx

@@ -0,0 +1,43 @@
+import { useEffect, useState } from "react";
+import { getShareBlocks } from "../api.js";
+import type { ReportRecord } from "../types.js";
+import type { ShareBlocks } from "../../share-blocks.js";
+import "./ShareBlocksPanel.css";
+
+const TABS: Array<{ key: keyof ShareBlocks; label: string }> = [
+  { key: "plainText", label: "Plain Text" },
+  { key: "markdown", label: "Markdown" },
+  { key: "slack", label: "Slack" },
+  { key: "emailHtml", label: "Email HTML" },
+];
+
+export function ShareBlocksPanel({ report }: { report: ReportRecord }) {
+  const [active, setActive] = useState<keyof ShareBlocks>("plainText");
+  const [data, setData] = useState<ShareBlocks | null>(null);
+  const [locked, setLocked] = useState(false);
+  const [copied, setCopied] = useState(false);
+
+  useEffect(() => {
+    setLocked(false);
+    setData(null);
+    getShareBlocks(report.id).then(setData).catch((error: Error) => {
+      if (error.message.includes("409")) setLocked(true);
+    });
+  }, [report.id]);
+
+  if (locked) return <section className="share-blocks-panel"><p className="share-blocks-panel__locked">Share blocks unlock after the report is approved.</p></section>;
+  if (!data) return <section className="share-blocks-panel"><p>Loading share blocks…</p></section>;
+
+  const value = data[active];
+  return <section className="share-blocks-panel">
+    <div className="share-blocks-panel__tabs">
+      {TABS.map((tab) => <button key={tab.key} className={`btn btn-sm ${active === tab.key ? "btn-primary" : ""}`} onClick={() => setActive(tab.key)}>{tab.label}</button>)}
+    </div>
+    <textarea className="input share-blocks-panel__content" readOnly value={value} />
+    <button className="btn btn-sm" onClick={async () => {
+      await navigator.clipboard.writeText(value);
+      setCopied(true);
+      setTimeout(() => setCopied(false), 1000);
+    }}>{copied ? "Copied" : "Copy"}</button>
+  </section>;
+}

package/dist/plugins/fusion-plugin-reports/src/dashboard/components/__tests__/ReportApprovalPanel.test.tsx

@@ -0,0 +1,38 @@
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { ReportApprovalPanel } from "../ReportApprovalPanel.js";
+
+vi.mock("../../api.js", () => ({
+  approveReport: vi.fn(async () => ({ ...baseReport, approvalState: "approved" })),
+  rejectReport: vi.fn(async () => ({ ...baseReport, approvalState: "rejected" })),
+  publishReport: vi.fn(async () => ({ ...baseReport, approvalState: "published" })),
+}));
+
+const baseReport: any = {
+  id: "rep_1",
+  approvalState: "awaiting_approval",
+  approvalHistory: [],
+  status: "review_complete",
+};
+
+afterEach(() => cleanup());
+
+describe("ReportApprovalPanel", () => {
+  it("renders actions for awaiting approval and posts approve", async () => {
+    const onReportChange = vi.fn();
+    render(<ReportApprovalPanel report={baseReport} onReportChange={onReportChange} />);
+    fireEvent.click(screen.getByText("Approve"));
+    await waitFor(() => expect(onReportChange).toHaveBeenCalled());
+  });
+
+  it("renders publish action for approved", () => {
+    render(<ReportApprovalPanel report={{ ...baseReport, approvalState: "approved" }} onReportChange={vi.fn()} />);
+    expect(screen.getByText("Publish")).toBeInTheDocument();
+  });
+
+  it("read-only for rejected", () => {
+    render(<ReportApprovalPanel report={{ id: "rep_1", status: "review_complete", approvalState: "rejected", approvalHistory: [{ action: "reject", decidedAt: "now", decidedBy: "u" }] } as any} onReportChange={vi.fn()} />);
+    expect(screen.queryByText("Publish")).toBeNull();
+    expect(screen.getByText(/reject by/i)).toBeInTheDocument();
+  });
+});

package/dist/plugins/fusion-plugin-reports/src/dashboard/components/__tests__/ShareBlocksPanel.test.tsx

@@ -0,0 +1,24 @@
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { ShareBlocksPanel } from "../ShareBlocksPanel.js";
+
+const getShareBlocks = vi.fn();
+vi.mock("../../api.js", () => ({ getShareBlocks: (...args: unknown[]) => getShareBlocks(...args) }));
+
+describe("ShareBlocksPanel", () => {
+  it("renders tabs and copies selected block", async () => {
+    getShareBlocks.mockResolvedValue({ plainText: "a", markdown: "b", slack: "c", emailHtml: "d" });
+    Object.assign(navigator, { clipboard: { writeText: vi.fn().mockResolvedValue(undefined) } });
+    render(<ShareBlocksPanel report={{ id: "rep_1" } as any} />);
+    await screen.findByText("Plain Text");
+    fireEvent.click(screen.getByText("Markdown"));
+    fireEvent.click(screen.getByText("Copy"));
+    await waitFor(() => expect(navigator.clipboard.writeText).toHaveBeenCalledWith("b"));
+  });
+
+  it("shows locked message on 409", async () => {
+    getShareBlocks.mockRejectedValue(new Error("409 Conflict"));
+    render(<ShareBlocksPanel report={{ id: "rep_1" } as any} />);
+    await screen.findByText(/unlock after the report is approved/i);
+  });
+});

package/dist/plugins/fusion-plugin-reports/src/dashboard/test-setup.ts

@@ -0,0 +1,18 @@
+import "@testing-library/jest-dom/vitest";
+import { vi } from "vitest";
+
+if (typeof window !== "undefined") {
+  Object.defineProperty(window, "matchMedia", {
+    writable: true,
+    value: vi.fn().mockImplementation((query: string) => ({
+      matches: false,
+      media: query,
+      onchange: null,
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+      addListener: vi.fn(),
+      removeListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+    })),
+  });
+}

package/dist/plugins/fusion-plugin-reports/src/dashboard/types.ts

@@ -0,0 +1,22 @@
+import type { Report, ReportCadence, ReportStatus } from "../store/report-types.js";
+
+export type ToastType = "success" | "error" | "info" | "warning";
+
+export interface ReportFilters {
+  cadence: "all" | ReportCadence;
+  status: "all" | ReportStatus;
+  from: string;
+  to: string;
+  q: string;
+  agentId: string;
+}
+
+export interface SectionRef {
+  id: string;
+  label: string;
+  hash: string;
+}
+
+export type ReportRecord = Report;
+
+export type ReportListItemVm = Pick<ReportRecord, "id" | "title" | "cadence" | "status" | "periodStart" | "periodEnd" | "createdAt" | "metadata">;

package/dist/plugins/fusion-plugin-reports/src/dashboard/useReportPreview.ts

@@ -0,0 +1,44 @@
+import { useEffect, useState } from "react";
+import { getReportPreviewHtml } from "./api.js";
+
+const cache = new Map<string, string>();
+
+export function useReportPreview(id?: string, projectId?: string) {
+  const [html, setHtml] = useState<string>("");
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!id) {
+      setHtml("");
+      setError(null);
+      return;
+    }
+    const key = `${projectId ?? ""}:${id}`;
+    const cached = cache.get(key);
+    if (cached) {
+      setHtml(cached);
+      setError(null);
+      return;
+    }
+    const controller = new AbortController();
+    setLoading(true);
+    setError(null);
+    getReportPreviewHtml(id, projectId)
+      .then((nextHtml) => {
+        if (controller.signal.aborted) return;
+        cache.set(key, nextHtml);
+        setHtml(nextHtml);
+      })
+      .catch((err: unknown) => {
+        if (controller.signal.aborted) return;
+        setError(err instanceof Error ? err.message : "Failed to load preview");
+      })
+      .finally(() => {
+        if (!controller.signal.aborted) setLoading(false);
+      });
+    return () => controller.abort();
+  }, [id, projectId]);
+
+  return { html, loading, error };
+}

package/dist/plugins/fusion-plugin-reports/src/dashboard/useReportSectionDiff.ts

@@ -0,0 +1,59 @@
+import { useMemo } from "react";
+import type { ReportRecord, SectionRef } from "./types.js";
+
+export interface SectionDiff {
+  added: SectionRef[];
+  removed: SectionRef[];
+  changed: SectionRef[];
+  unchanged: SectionRef[];
+}
+
+const ALL_SECTIONS: Array<{ id: string; label: string }> = [
+  { id: "summary", label: "Summary" },
+  { id: "system-wins", label: "System wins" },
+  { id: "system-highlights", label: "System highlights" },
+  { id: "system-lowlights", label: "System lowlights" },
+  { id: "system-proposals", label: "System proposals" },
+  { id: "system-deep-dives", label: "System deep dives" },
+  { id: "agent-card", label: "Per-agent" },
+  { id: "data-coverage", label: "Data coverage" },
+  { id: "review-panel", label: "Review panel" },
+];
+
+function extractValue(report: ReportRecord | undefined, id: string): unknown {
+  if (!report) return undefined;
+  switch (id) {
+    case "summary": return report.metadata?.summary;
+    case "system-wins": return report.metadata?.wins;
+    case "system-highlights": return report.metadata?.highlights;
+    case "system-lowlights": return report.metadata?.lowlights;
+    case "system-proposals": return report.metadata?.proposals;
+    case "system-deep-dives": return report.metadata?.deepDives;
+    case "agent-card": return report.metadata?.perAgent;
+    case "data-coverage": return report.metadata?.dataCoverage;
+    case "review-panel": return report.combinedReview;
+    default: return undefined;
+  }
+}
+
+export function diffReportSections(a?: ReportRecord, b?: ReportRecord): SectionDiff {
+  const added: SectionRef[] = [];
+  const removed: SectionRef[] = [];
+  const changed: SectionRef[] = [];
+  const unchanged: SectionRef[] = [];
+
+  for (const section of ALL_SECTIONS) {
+    const left = extractValue(a, section.id);
+    const right = extractValue(b, section.id);
+    const ref: SectionRef = { id: section.id, label: section.label, hash: section.id };
+    if (left == null && right != null) added.push(ref);
+    else if (left != null && right == null) removed.push(ref);
+    else if (JSON.stringify(left) !== JSON.stringify(right)) changed.push(ref);
+    else unchanged.push(ref);
+  }
+  return { added, removed, changed, unchanged };
+}
+
+export function useReportSectionDiff(a?: ReportRecord, b?: ReportRecord): SectionDiff {
+  return useMemo(() => diffReportSections(a, b), [a, b]);
+}

package/dist/plugins/fusion-plugin-reports/src/dashboard/useReports.ts

@@ -0,0 +1,71 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { getReport, listReports } from "./api.js";
+import type { ReportFilters, ReportRecord, ToastType } from "./types.js";
+
+const DEFAULT_FILTERS: ReportFilters = { cadence: "all", status: "all", from: "", to: "", q: "", agentId: "" };
+
+export function useReports({ projectId, addToast }: { projectId?: string; addToast: (message: string, type?: ToastType) => void }) {
+  const [filters, setFilters] = useState<ReportFilters>(DEFAULT_FILTERS);
+  const [reports, setReports] = useState<ReportRecord[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [selectedId, setSelectedId] = useState<string | undefined>();
+  const [selectedReport, setSelectedReport] = useState<ReportRecord | undefined>();
+  const [compareMode, setCompareMode] = useState(false);
+  const [compareA, setCompareA] = useState<string | undefined>();
+  const [compareB, setCompareB] = useState<string | undefined>();
+
+  useEffect(() => {
+    const controller = new AbortController();
+    setLoading(true);
+    listReports({
+      cadence: filters.cadence === "all" ? undefined : filters.cadence,
+      status: filters.status === "all" ? undefined : filters.status,
+      from: filters.from || undefined,
+      to: filters.to || undefined,
+      q: filters.q || undefined,
+      agentId: filters.agentId || undefined,
+      projectId,
+    }).then((items) => {
+      if (controller.signal.aborted) return;
+      setReports(items);
+      if (!selectedId && items[0]) setSelectedId(items[0].id);
+    }).catch((err: unknown) => {
+      if (controller.signal.aborted) return;
+      addToast(err instanceof Error ? err.message : "Failed to load reports", "error");
+    }).finally(() => {
+      if (!controller.signal.aborted) setLoading(false);
+    });
+    return () => controller.abort();
+  }, [filters, projectId, addToast, selectedId]);
+
+  useEffect(() => {
+    if (!selectedId) return;
+    getReport(selectedId, projectId).then(setSelectedReport).catch((err: unknown) => {
+      addToast(err instanceof Error ? err.message : "Failed to load report", "error");
+    });
+  }, [selectedId, projectId, addToast]);
+
+  const selectId = useCallback((id: string) => setSelectedId(id), []);
+  const enterCompareMode = useCallback(() => setCompareMode(true), []);
+  const closeCompareMode = useCallback(() => setCompareMode(false), []);
+  const setCompareSlot = useCallback((slot: "a" | "b", id: string) => {
+    if (slot === "a") setCompareA(id);
+    else setCompareB(id);
+  }, []);
+
+  return useMemo(() => ({
+    filters,
+    setFilters,
+    reports,
+    loading,
+    selectedId,
+    selectedReport,
+    selectId,
+    compareMode,
+    compareA,
+    compareB,
+    enterCompareMode,
+    closeCompareMode,
+    setCompareSlot,
+  }), [filters, reports, loading, selectedId, selectedReport, selectId, compareMode, compareA, compareB, enterCompareMode, closeCompareMode, setCompareSlot]);
+}

package/dist/plugins/fusion-plugin-reports/src/dashboard/useViewportMode.ts

@@ -0,0 +1,13 @@
+import { useEffect, useState } from "react";
+
+export function useViewportMode() {
+  const [mobile, setMobile] = useState(false);
+  useEffect(() => {
+    const mq = window.matchMedia("(max-width: 768px)");
+    const onChange = () => setMobile(mq.matches);
+    onChange();
+    mq.addEventListener("change", onChange);
+    return () => mq.removeEventListener("change", onChange);
+  }, []);
+  return { mobile };
+}

package/dist/plugins/fusion-plugin-reports/src/dashboard-view.tsx

@@ -0,0 +1,6 @@
+import type { PluginDashboardViewContext } from "@fusion/dashboard/app/plugins/types";
+import { ReportsView } from "./dashboard/ReportsView.js";
+
+export function ReportsDashboardView({ context }: { context?: PluginDashboardViewContext }) {
+  return <ReportsView projectId={context?.projectId} addToast={context?.addToast ?? (() => undefined)} />;
+}

package/dist/plugins/fusion-plugin-reports/src/index.ts

@@ -1,11 +1,22 @@
 import type { PluginContext } from "@fusion/core";
 import { definePlugin } from "@fusion/plugin-sdk";
+import { initializeApprovalState } from "./approval.js";
 import { runReviewPanel } from "./review-panel.js";
 import { ensureReportSchema } from "./report-schema.js";
+import { createReportApprovalRoutes } from "./routes/report-approval-routes.js";
+import { createReportExportRoutes } from "./routes/report-export-routes.js";
+import { createReportListRoutes } from "./routes/report-list-routes.js";
 import type { CombinedReview, ReviewPanelMember, RunReviewPanelInput } from "./review-types.js";
+import {
+  getApprovalRequired,
+  getApproverAgentIds,
+  getAutoPublishOnApproval,
+  getPublishTargets,
+  settingsSchema,
+} from "./settings.js";
 import type { ReportCadence, ReportCreateInput } from "./store/report-types.js";
 import { ReportStore } from "./store/report-store.js";
-import { settingsSchema } from "./settings.js";
+export { ReportsDashboardView } from "./dashboard-view.js";
 
 const plugin = definePlugin({
   manifest: {
@@ -21,6 +32,17 @@ const plugin = definePlugin({
   hooks: {
     onSchemaInit: ensureReportSchema,
   },
+  routes: [...createReportListRoutes(), ...createReportExportRoutes(), ...createReportApprovalRoutes()],
+  dashboardViews: [
+    {
+      viewId: "reports",
+      label: "Reports",
+      componentPath: "./dashboard-view",
+      icon: "FileText",
+      placement: "primary",
+      order: 35,
+    },
+  ],
 });
 
 export interface RunGeneratedReportReviewInput {
@@ -73,15 +95,39 @@ export async function runGeneratedReportReview(input: RunGeneratedReportReviewIn
     cwd: input.cwd,
   }, ctx);
 
-  store.attachReview(report.id, combinedReview);
+  const reviewed = store.attachReview(report.id, combinedReview);
+
+  const nextApprovalState = initializeApprovalState(reviewed.status, {
+    approvalRequired: getApprovalRequired(ctx.settings),
+    autoPublishOnApproval: getAutoPublishOnApproval(ctx.settings),
+    approverAgentIds: getApproverAgentIds(ctx.settings),
+    publishTargets: getPublishTargets(ctx.settings),
+  });
+
+  if (nextApprovalState !== "not_required") {
+    const now = new Date().toISOString();
+    store.updateReport(report.id, {
+      approvalState: nextApprovalState,
+      ...(nextApprovalState === "approved"
+        ? { status: "approved", approvedAt: now, approvedBy: "system" }
+        : {}),
+      ...(nextApprovalState === "published" ? { status: "published", publishedAt: now } : {}),
+    });
+  }
+
   return combinedReview;
 }
 
 export default plugin;
 
 export * from "./settings.js";
+export * from "./cadence.js";
+export * from "./aggregation.js";
+export * from "./pipeline.js";
+export * from "./runs-store.js";
 export * from "./review-types.js";
 export * from "./review-panel.js";
 export { ensureReportSchema } from "./report-schema.js";
 export { ReportStore, ReportStoreError, type ReportStoreEvents } from "./store/report-store.js";
 export * from "./store/report-types.js";
+export * from "./render/index.js";

package/dist/plugins/fusion-plugin-reports/src/pipeline.ts

@@ -0,0 +1,58 @@
+/**
+ * INTERIM ORCHESTRATOR. FN-3779 replaces this with cadence-registry + cron-sentinel wiring;
+ * FN-3780 replaces the aggregate dependency with the real aggregation layer.
+ * Keep the `ReportsPipelineDependencies` shape stable so both can plug in without callsite churn.
+ */
+import type { ReportsAggregator } from "./aggregation.js";
+import type { ReportsCadence } from "./cadence.js";
+import type { ReportRunRecord, ReportsRunsStore } from "./runs-store.js";
+
+export interface ReportsPipelineDependencies {
+  runsStore: ReportsRunsStore;
+  aggregate: ReportsAggregator;
+}
+
+export interface StartPipelineInput {
+  runId: string;
+  cadence: ReportsCadence;
+  settings: Record<string, unknown>;
+  now?: Date;
+}
+
+export async function startReportsPipeline(
+  input: StartPipelineInput,
+  deps: ReportsPipelineDependencies,
+): Promise<ReportRunRecord> {
+  const nowIso = (input.now ?? new Date()).toISOString();
+
+  const created = await deps.runsStore.create({
+    id: input.runId,
+    cadence: input.cadence,
+    status: "queued",
+    createdAt: nowIso,
+    updatedAt: nowIso,
+  });
+
+  await deps.runsStore.update(input.runId, { status: "running", updatedAt: nowIso });
+
+  try {
+    await deps.aggregate({
+      runId: input.runId,
+      cadence: input.cadence,
+      settings: input.settings,
+    });
+
+    const updatedAt = new Date().toISOString();
+    const reviewed = await deps.runsStore.update(input.runId, { status: "review", updatedAt });
+    return reviewed ?? { ...created, status: "review", updatedAt };
+  } catch (error) {
+    const updatedAt = new Date().toISOString();
+    const message = error instanceof Error ? error.message : String(error);
+    const failed = await deps.runsStore.update(input.runId, {
+      status: "failed",
+      error: message,
+      updatedAt,
+    });
+    return failed ?? { ...created, status: "failed", error: message, updatedAt };
+  }
+}

package/dist/plugins/fusion-plugin-reports/src/render/__tests__/escape.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import { escapeAttr, escapeHtml } from "../escape.js";
+
+describe("escape", () => {
+  it("escapes html special characters", () => {
+    expect(escapeHtml("&<>'\"")).toBe("&amp;&lt;&gt;&#39;&quot;");
+  });
+
+  it("escapes attribute-sensitive characters", () => {
+    expect(escapeAttr("a`b&c")).toBe("a&#96;b&amp;c");
+  });
+
+  it("passes unicode through", () => {
+    expect(escapeHtml("こんにちは 🌍")).toBe("こんにちは 🌍");
+  });
+
+  it("passes unicode through in attributes", () => {
+    expect(escapeAttr("こんにちは 🌍")).toBe("こんにちは 🌍");
+  });
+});

package/dist/plugins/fusion-plugin-reports/src/render/__tests__/html-template.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, it } from "vitest";
+import type { Report } from "../../store/report-types.js";
+import { renderReportHtml } from "../html-template.js";
+
+function createRecord(overrides: Partial<Report> = {}, metadata: Record<string, unknown> = {}): Report {
+  const base: Report = {
+    id: "rep_1",
+    cadence: "daily",
+    periodStart: "2026-05-01",
+    periodEnd: "2026-05-02",
+    title: "Weekly report",
+    status: "review_complete",
+    generationStartedAt: "2026-05-02T00:00:00.000Z",
+    generationCompletedAt: "2026-05-02T00:01:00.000Z",
+    reviewStartedAt: null,
+    reviewCompletedAt: null,
+    approvedAt: null,
+    approvedBy: null,
+    publishedAt: null,
+    archivedAt: null,
+    failureReason: null,
+    approvalState: "not_required",
+    approvalHistory: [],
+    draftMarkdown: null,
+    renderedHtmlPath: null,
+    combinedReview: null,
+    createdAt: "2026-05-02T00:00:00.000Z",
+    updatedAt: "2026-05-02T00:01:00.000Z",
+    metadata,
+    renderedHtml: null,
+    renderedHtmlGeneratedAt: null,
+  };
+  return {
+    ...base,
+    ...overrides,
+    renderedHtml: overrides.renderedHtml ?? base.renderedHtml,
+    renderedHtmlGeneratedAt: overrides.renderedHtmlGeneratedAt ?? base.renderedHtmlGeneratedAt,
+  };
+}
+
+describe("renderReportHtml", () => {
+  it("renders shell for empty record", () => {
+    const html = renderReportHtml(createRecord());
+    expect(html).toContain("<!doctype html>");
+    expect(html).toContain("data-section=\"data-coverage\"");
+  });
+
+  it("renders mixed sections with markers", () => {
+    const html = renderReportHtml(createRecord({}, {
+      sections: {
+        summary: "hello",
+        system: { wins: ["w1"], highlights: ["h1"], lowlights: ["l1"], proposals: ["p1"], deepDives: ["d1"] },
+        perAgent: [{ agentId: "a1", wins: ["x"] }],
+      },
+    }));
+    expect(html).toContain('data-section="summary"');
+    expect(html).toContain('data-section="system-wins"');
+    expect(html).toContain('data-section="system-highlights"');
+    expect(html).toContain('data-section="system-lowlights"');
+    expect(html).toContain('data-section="system-proposals"');
+    expect(html).toContain('data-section="system-deep-dives"');
+    expect(html).toContain('data-section="agent-card"');
+  });
+
+  it("omits toggled off sections", () => {
+    const html = renderReportHtml(createRecord({}, {
+      settings: { enabledSections: ["wins"] },
+      sections: { system: { wins: ["w1"], highlights: ["h1"] } },
+    }));
+    expect(html).toContain('data-section="system-wins"');
+    expect(html).not.toContain('data-section="system-highlights"');
+  });
+
+  it("respects section order", () => {
+    const html = renderReportHtml(createRecord({}, {
+      settings: { sectionOrder: ["proposals", "wins"], enabledSections: ["wins", "proposals"] },
+      sections: { system: { wins: ["w1"], proposals: ["p1"] } },
+    }));
+    expect(html.indexOf('data-section="system-proposals"')).toBeLessThan(html.indexOf('data-section="system-wins"'));
+  });
+
+  it("renders per-agent cards with stable ids", () => {
+    const html = renderReportHtml(createRecord({}, {
+      sections: { perAgent: [{ agentId: "agent-1" }, { agentId: "agent-2" }] },
+    }));
+    expect(html).toContain('data-agent-id="agent-1"');
+    expect(html).toContain('data-agent-id="agent-2"');
+  });
+
+  it("escapes hostile inputs", () => {
+    const html = renderReportHtml(createRecord({}, {
+      sections: { summary: '<script>alert(1)</script> " onmouseover=' },
+    }));
+    expect(html).not.toContain("<script>alert(1)</script>");
+    expect(html).not.toContain("javascript:");
+  });
+
+  it("applies explicit theme", () => {
+    const dark = renderReportHtml(createRecord(), { theme: "dark" });
+    const light = renderReportHtml(createRecord(), { theme: "light" });
+    expect(dark).toContain('data-theme="dark"');
+    expect(light).toContain('data-theme="light"');
+  });
+
+  it("returns body-only when includeChrome false", () => {
+    const body = renderReportHtml(createRecord(), { includeChrome: false });
+    expect(body.startsWith("<!doctype html>")).toBe(false);
+    expect(body.startsWith("<article")).toBe(true);
+  });
+});