@runfusion/fusion 0.26.0 → 0.27.0

package/dist/plugins/fusion-plugin-cli-printing-press/src/wizard/types.ts

@@ -0,0 +1,33 @@
+export type CredentialPattern =
+  | { kind: "none" }
+  | { kind: "apiKey"; header: string; envVar: string }
+  | { kind: "bearerToken"; envVar: string }
+  | { kind: "basicAuth"; usernameEnvVar: string; passwordEnvVar: string };
+// TODO(FN-3762/FN-3766): OAuth credential variants.
+
+export interface ServiceEndpoint {
+  id: string;
+  name: string;
+  method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+  path: string;
+  summary?: string;
+  params?: string;
+}
+
+export interface ServiceDraft {
+  id: string;
+  name: string;
+  slug: string;
+  description: string;
+  baseUrl: string;
+  transport: "http";
+  endpoints: ServiceEndpoint[];
+  credential: CredentialPattern;
+  createdAt: string;
+  updatedAt: string;
+  regeneratedAt?: string;
+  generatedAt?: string;
+  artifactPath?: string;
+}
+
+export type WizardStep = "basics" | "transport" | "endpoints" | "credentials" | "review";

package/dist/plugins/fusion-plugin-cli-printing-press/src/wizard/validation.ts

@@ -0,0 +1,63 @@
+import type { CredentialPattern, ServiceDraft, ServiceEndpoint } from "./types.js";
+
+type Ok = { ok: true };
+type Fail = { ok: false; errors: Record<string, string> };
+export type ValidationResult = Ok | Fail;
+
+const SLUG_PATTERN = /^[a-z0-9-]+$/;
+const METHODS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
+
+function fail(errors: Record<string, string>): Fail {
+  return { ok: false, errors };
+}
+
+export function validateBasics(draft: ServiceDraft): ValidationResult {
+  const errors: Record<string, string> = {};
+  if (!draft.name.trim()) errors.name = "Name is required";
+  if (!SLUG_PATTERN.test(draft.slug)) errors.slug = "Slug must use lowercase letters, numbers, and single hyphens";
+  if (!draft.baseUrl.trim()) {
+    errors.baseUrl = "Base URL is required";
+  } else {
+    try { new URL(draft.baseUrl); } catch { errors.baseUrl = "Base URL must be a valid URL"; }
+  }
+  return Object.keys(errors).length ? fail(errors) : { ok: true };
+}
+
+export function validateTransport(draft: ServiceDraft): ValidationResult {
+  return draft.transport === "http" ? { ok: true } : fail({ transport: "Only HTTP transport is supported in v1" });
+}
+
+function validateEndpoint(endpoint: ServiceEndpoint, index: number): Record<string, string> {
+  const errors: Record<string, string> = {};
+  if (!endpoint.name.trim()) errors[`endpoints.${index}.name`] = "Endpoint name is required";
+  if (!METHODS.has(endpoint.method)) errors[`endpoints.${index}.method`] = "HTTP method is invalid";
+  if (!endpoint.path.trim()) errors[`endpoints.${index}.path`] = "Endpoint path is required";
+  return errors;
+}
+
+export function validateEndpoints(draft: ServiceDraft): ValidationResult {
+  const errors: Record<string, string> = {};
+  if (draft.endpoints.length < 1) errors.endpoints = "At least one endpoint is required";
+  draft.endpoints.forEach((endpoint, index) => Object.assign(errors, validateEndpoint(endpoint, index)));
+  return Object.keys(errors).length ? fail(errors) : { ok: true };
+}
+
+export function validateCredentials(credential: CredentialPattern): ValidationResult {
+  const errors: Record<string, string> = {};
+  if (credential.kind === "apiKey") {
+    if (!credential.header.trim()) errors.header = "Header is required";
+    if (!credential.envVar.trim()) errors.envVar = "Environment variable is required";
+  }
+  if (credential.kind === "bearerToken" && !credential.envVar.trim()) errors.envVar = "Environment variable is required";
+  if (credential.kind === "basicAuth") {
+    if (!credential.usernameEnvVar.trim()) errors.usernameEnvVar = "Username env var is required";
+    if (!credential.passwordEnvVar.trim()) errors.passwordEnvVar = "Password env var is required";
+  }
+  return Object.keys(errors).length ? fail(errors) : { ok: true };
+}
+
+export function validateDraft(draft: ServiceDraft): ValidationResult {
+  const validations = [validateBasics(draft), validateTransport(draft), validateEndpoints(draft), validateCredentials(draft.credential)];
+  const errors = validations.filter((r): r is Fail => !r.ok).reduce((acc, item) => ({ ...acc, ...item.errors }), {});
+  return Object.keys(errors).length ? fail(errors) : { ok: true };
+}

package/dist/plugins/fusion-plugin-cursor-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/cursor-runtime",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "module",
   "exports": {
     ".": {

package/dist/plugins/fusion-plugin-dependency-graph/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/dependency-graph",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "type": "module",
   "exports": {
     ".": {

package/dist/plugins/fusion-plugin-droid-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/droid-runtime",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "type": "module",
   "exports": {
     ".": {

package/dist/plugins/fusion-plugin-hermes-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/hermes-runtime",
-  "version": "0.2.34",
+  "version": "0.2.35",
   "type": "module",
   "exports": {
     ".": {

package/dist/plugins/fusion-plugin-openclaw-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/openclaw-runtime",
-  "version": "0.2.34",
+  "version": "0.2.35",
   "type": "module",
   "exports": {
     ".": {

package/dist/plugins/fusion-plugin-paperclip-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/paperclip-runtime",
-  "version": "0.2.34",
+  "version": "0.2.35",
   "type": "module",
   "exports": {
     ".": {

package/dist/plugins/fusion-plugin-reports/manifest.json

@@ -5,6 +5,16 @@
   "description": "Generates beautiful HTML system-activity reports with multi-agent review.",
   "author": "Fusion Team",
   "fusionVersion": ">=0.1.0",
+  "dashboardViews": [
+    {
+      "viewId": "reports",
+      "label": "Reports",
+      "componentPath": "./dashboard-view",
+      "icon": "FileText",
+      "placement": "primary",
+      "order": 35
+    }
+  ],
   "settingsSchema": {
     "dailyEnabled": { "type": "boolean", "label": "Enable Daily Reports", "description": "Generate daily reports on schedule.", "group": "Schedules", "defaultValue": true },
     "dailyCron": { "type": "string", "label": "Daily Schedule (cron)", "description": "Cron expression for daily report generation.", "group": "Schedules", "required": true, "defaultValue": "0 8 * * *" },

package/dist/plugins/fusion-plugin-reports/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/reports",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "module",
   "description": "Reports plugin for Fusion",
   "private": true,
@@ -8,6 +8,14 @@
     ".": {
       "types": "./src/index.ts",
       "import": "./src/index.ts"
+    },
+    "./render": {
+      "types": "./src/render/index.ts",
+      "import": "./src/render/index.ts"
+    },
+    "./dashboard-view": {
+      "types": "./src/dashboard-view.tsx",
+      "import": "./src/dashboard-view.tsx"
     }
   },
   "scripts": {
@@ -16,9 +24,17 @@
   },
   "dependencies": {
     "@fusion/core": "workspace:*",
-    "@fusion/plugin-sdk": "workspace:*"
+    "@fusion/dashboard": "workspace:*",
+    "@fusion/plugin-sdk": "workspace:*",
+    "lucide-react": "^0.542.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.2.4"
   },
   "devDependencies": {
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/react": "^19.0.0",
     "@types/node": "^25.5.2",
     "typescript": "^5.7.0",
     "vitest": "^3.2.4"

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

@@ -0,0 +1,164 @@
+import { describe, expect, it } from "vitest";
+import { applyDecision, nextApprovalState, type ApprovalAction, type ApprovalActor, type ApprovalDecision, type ApprovalSettings, type ApprovalState } from "../approval.js";
+import type { Report } from "../store/report-types.js";
+
+interface MatrixCase {
+  approvalRequired: boolean;
+  autoPublishOnApproval: boolean;
+  actorIsApprover: boolean;
+  action: ApprovalAction;
+  expected: ApprovalState | "invalid_transition" | "unauthorized";
+}
+
+const matrix: MatrixCase[] = [
+  { approvalRequired: false, autoPublishOnApproval: false, actorIsApprover: false, action: "approve", expected: "approved" },
+  { approvalRequired: false, autoPublishOnApproval: false, actorIsApprover: false, action: "reject", expected: "rejected" },
+  { approvalRequired: false, autoPublishOnApproval: false, actorIsApprover: false, action: "publish", expected: "invalid_transition" },
+  { approvalRequired: false, autoPublishOnApproval: false, actorIsApprover: true, action: "approve", expected: "approved" },
+  { approvalRequired: false, autoPublishOnApproval: false, actorIsApprover: true, action: "reject", expected: "rejected" },
+  { approvalRequired: false, autoPublishOnApproval: false, actorIsApprover: true, action: "publish", expected: "invalid_transition" },
+  { approvalRequired: false, autoPublishOnApproval: true, actorIsApprover: false, action: "approve", expected: "published" },
+  { approvalRequired: false, autoPublishOnApproval: true, actorIsApprover: false, action: "reject", expected: "rejected" },
+  { approvalRequired: false, autoPublishOnApproval: true, actorIsApprover: false, action: "publish", expected: "invalid_transition" },
+  { approvalRequired: false, autoPublishOnApproval: true, actorIsApprover: true, action: "approve", expected: "published" },
+  { approvalRequired: false, autoPublishOnApproval: true, actorIsApprover: true, action: "reject", expected: "rejected" },
+  { approvalRequired: false, autoPublishOnApproval: true, actorIsApprover: true, action: "publish", expected: "invalid_transition" },
+  { approvalRequired: true, autoPublishOnApproval: false, actorIsApprover: false, action: "approve", expected: "unauthorized" },
+  { approvalRequired: true, autoPublishOnApproval: false, actorIsApprover: false, action: "reject", expected: "unauthorized" },
+  { approvalRequired: true, autoPublishOnApproval: false, actorIsApprover: false, action: "publish", expected: "unauthorized" },
+  { approvalRequired: true, autoPublishOnApproval: false, actorIsApprover: true, action: "approve", expected: "approved" },
+  { approvalRequired: true, autoPublishOnApproval: false, actorIsApprover: true, action: "reject", expected: "rejected" },
+  { approvalRequired: true, autoPublishOnApproval: false, actorIsApprover: true, action: "publish", expected: "invalid_transition" },
+  { approvalRequired: true, autoPublishOnApproval: true, actorIsApprover: false, action: "approve", expected: "unauthorized" },
+  { approvalRequired: true, autoPublishOnApproval: true, actorIsApprover: false, action: "reject", expected: "unauthorized" },
+  { approvalRequired: true, autoPublishOnApproval: true, actorIsApprover: false, action: "publish", expected: "unauthorized" },
+  { approvalRequired: true, autoPublishOnApproval: true, actorIsApprover: true, action: "approve", expected: "published" },
+  { approvalRequired: true, autoPublishOnApproval: true, actorIsApprover: true, action: "reject", expected: "rejected" },
+  { approvalRequired: true, autoPublishOnApproval: true, actorIsApprover: true, action: "publish", expected: "invalid_transition" },
+];
+
+function makeSettings(input: Pick<MatrixCase, "approvalRequired" | "autoPublishOnApproval" | "actorIsApprover">): ApprovalSettings {
+  return {
+    approvalRequired: input.approvalRequired,
+    autoPublishOnApproval: input.autoPublishOnApproval,
+    approverAgentIds: input.actorIsApprover ? ["approver-1"] : ["approver-2"],
+    publishTargets: ["dashboard"],
+  };
+}
+
+function makeDecision(action: ApprovalAction): ApprovalDecision {
+  return { action, decidedAt: "2026-05-10T00:00:00.000Z", decidedBy: "approver-1", note: "ship" };
+}
+
+function makeReport(state: ApprovalState): Report {
+  return {
+    id: "rep_1",
+    cadence: "daily",
+    periodStart: "2026-05-01",
+    periodEnd: "2026-05-01",
+    title: "Title",
+    status: "review_complete",
+    generationStartedAt: "2026-05-01T00:00:00.000Z",
+    generationCompletedAt: null,
+    reviewStartedAt: null,
+    reviewCompletedAt: "2026-05-01T01:00:00.000Z",
+    approvedAt: null,
+    approvedBy: null,
+    publishedAt: null,
+    archivedAt: null,
+    failureReason: null,
+    approvalState: state,
+    approvalHistory: [],
+    draftMarkdown: "# x",
+    renderedHtmlPath: null,
+    renderedHtml: null,
+    renderedHtmlGeneratedAt: null,
+    metadata: {},
+    combinedReview: null,
+    createdAt: "2026-05-01T00:00:00.000Z",
+    updatedAt: "2026-05-01T00:00:00.000Z",
+  };
+}
+
+describe("approval state machine", () => {
+  it.each(matrix)("transition matrix %#", (entry) => {
+    const settings = makeSettings(entry);
+    const actor: ApprovalActor = { id: "approver-1", type: "agent" };
+    const result = nextApprovalState("awaiting_approval", entry.action, settings, actor);
+    if ("error" in result) {
+      expect(result.error).toBe(entry.expected);
+      return;
+    }
+    expect(result.next).toBe(entry.expected);
+  });
+
+  it("returns invalid_transition for not_required actions", () => {
+    const settings: ApprovalSettings = {
+      approvalRequired: true,
+      autoPublishOnApproval: false,
+      approverAgentIds: ["approver-1"],
+      publishTargets: [],
+    };
+    const actor: ApprovalActor = { id: "approver-1", type: "agent" };
+    expect(nextApprovalState("not_required", "approve", settings, actor)).toEqual({ error: "invalid_transition" });
+    expect(nextApprovalState("not_required", "reject", settings, actor)).toEqual({ error: "invalid_transition" });
+    expect(nextApprovalState("not_required", "publish", settings, actor)).toEqual({ error: "invalid_transition" });
+  });
+
+  it("allows any human when approverAgentIds is empty", () => {
+    const settings: ApprovalSettings = {
+      approvalRequired: true,
+      autoPublishOnApproval: false,
+      approverAgentIds: [],
+      publishTargets: [],
+    };
+    const human: ApprovalActor = { id: "u-1", type: "human" };
+    expect(nextApprovalState("awaiting_approval", "approve", settings, human)).toEqual({ next: "approved" });
+  });
+
+  it("keeps agents unauthorized when approverAgentIds is empty", () => {
+    const settings: ApprovalSettings = {
+      approvalRequired: true,
+      autoPublishOnApproval: false,
+      approverAgentIds: [],
+      publishTargets: [],
+    };
+    const agent: ApprovalActor = { id: "approver-1", type: "agent" };
+    expect(nextApprovalState("awaiting_approval", "approve", settings, agent)).toEqual({ error: "unauthorized" });
+  });
+
+  it("applyDecision auto-publish chain updates report fields", () => {
+    const report = makeReport("awaiting_approval");
+    const settings: ApprovalSettings = {
+      approvalRequired: true,
+      autoPublishOnApproval: true,
+      approverAgentIds: ["approver-1"],
+      publishTargets: ["dashboard", "html-export"],
+    };
+
+    const result = applyDecision(report, makeDecision("approve"), settings, { id: "approver-1", type: "agent" });
+    expect("error" in result).toBe(false);
+    if ("error" in result) return;
+    expect(result.updatedReport.approvalState).toBe("published");
+    expect(result.updatedReport.status).toBe("published");
+    expect(result.updatedReport.approvedBy).toBe("approver-1");
+    expect(result.sideEffects.publishTargets).toEqual(["dashboard", "html-export"]);
+  });
+
+  it("applyDecision publish action from approved sets published state", () => {
+    const report = makeReport("approved");
+    const settings: ApprovalSettings = {
+      approvalRequired: true,
+      autoPublishOnApproval: false,
+      approverAgentIds: ["approver-1"],
+      publishTargets: ["dashboard"],
+    };
+
+    const result = applyDecision(report, makeDecision("publish"), settings, { id: "approver-1", type: "agent" });
+    expect("error" in result).toBe(false);
+    if ("error" in result) return;
+    expect(result.updatedReport.approvalState).toBe("published");
+    expect(result.updatedReport.status).toBe("published");
+    expect(result.updatedReport.publishedAt).toBe("2026-05-10T00:00:00.000Z");
+  });
+});

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

@@ -42,6 +42,20 @@ describe("reports plugin manifest", () => {
     expect(plugin.manifest.fusionVersion).toBe(manifest.fusionVersion);
   });
 
+  it("registers dashboard view", () => {
+    expect(plugin.dashboardViews).toEqual([
+      {
+        viewId: "reports",
+        label: "Reports",
+        componentPath: "./dashboard-view",
+        icon: "FileText",
+        placement: "primary",
+        order: 35,
+      },
+    ]);
+    expect(manifest.dashboardViews).toEqual(plugin.dashboardViews);
+  });
+
   it("includes full settings schema", () => {
     expect(plugin.manifest.settingsSchema).toBeDefined();
     for (const key of expectedKeys) {

package/dist/plugins/fusion-plugin-reports/src/__tests__/routes-approval.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, it, vi } from "vitest";
+import type { PluginContext } from "@fusion/core";
+import type { Report } from "../store/report-types.js";
+import { createReportApprovalRoutes } from "../routes/report-approval-routes.js";
+
+function makeReport(overrides: Partial<Report> = {}): Report {
+  return {
+    id: "rep_1",
+    cadence: "daily",
+    periodStart: "2026-05-01",
+    periodEnd: "2026-05-01",
+    title: "Report",
+    status: "review_complete",
+    generationStartedAt: "2026-05-01T00:00:00.000Z",
+    generationCompletedAt: null,
+    reviewStartedAt: null,
+    reviewCompletedAt: null,
+    approvedAt: null,
+    approvedBy: null,
+    publishedAt: null,
+    archivedAt: null,
+    failureReason: null,
+    approvalState: "awaiting_approval",
+    approvalHistory: [],
+    draftMarkdown: null,
+    renderedHtmlPath: null,
+    renderedHtml: null,
+    renderedHtmlGeneratedAt: null,
+    metadata: {},
+    combinedReview: null,
+    createdAt: "2026-05-01T00:00:00.000Z",
+    updatedAt: "2026-05-01T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+function ctxWithStore(store: { getReport: (id: string) => Report | null; updateReport: (id: string, patch: Partial<Report>) => Report }, settings: Record<string, unknown> = {}): PluginContext {
+  return {
+    pluginId: "fusion-plugin-reports",
+    taskStore: { getDatabase: () => ({}), getReportStore: () => store } as any,
+    settings,
+    logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
+    emitEvent: vi.fn(),
+  } as PluginContext;
+}
+
+function route(path: string, method: string) {
+  return createReportApprovalRoutes().find((entry) => entry.path === path && entry.method === method)!;
+}
+
+describe("report approval routes", () => {
+  it("approve then publish happy path", async () => {
+    let current = makeReport({ approvalState: "awaiting_approval" });
+    const store = {
+      getReport: vi.fn(() => current),
+      updateReport: vi.fn((_id: string, patch: Partial<Report>) => {
+        current = { ...current, ...patch };
+        return current;
+      }),
+    };
+    const ctx = ctxWithStore(store, { approvalRequired: true, autoPublishOnApproval: false, approverAgentIds: ["agent-1"] });
+
+    const approve = await route("/reports/:id/approve", "POST").handler({ params: { id: "rep_1" }, headers: { "x-fusion-actor-type": "agent", "x-fusion-user": "agent-1" } }, ctx as any) as any;
+    expect(approve.status).toBe(200);
+    expect(approve.body.report.approvalState).toBe("approved");
+
+    const publish = await route("/reports/:id/publish", "POST").handler({ params: { id: "rep_1" }, headers: { "x-fusion-actor-type": "agent", "x-fusion-user": "agent-1" } }, ctx as any) as any;
+    expect(publish.status).toBe(200);
+    expect(publish.body.report.approvalState).toBe("published");
+  });
+
+  it("supports reject path", async () => {
+    const store = {
+      getReport: vi.fn(() => makeReport()),
+      updateReport: vi.fn((_id: string, patch: Partial<Report>) => ({ ...makeReport(), ...patch })),
+    };
+    const ctx = ctxWithStore(store, { approvalRequired: true, autoPublishOnApproval: false, approverAgentIds: ["agent-1"] });
+    const reject = await route("/reports/:id/reject", "POST").handler({ params: { id: "rep_1" }, headers: { "x-fusion-actor-type": "agent", "x-fusion-user": "agent-1" } }, ctx as any) as any;
+    expect(reject.status).toBe(200);
+    expect(reject.body.report.approvalState).toBe("rejected");
+  });
+
+  it("returns 403 for unauthorized approver", async () => {
+    const store = {
+      getReport: vi.fn(() => makeReport()),
+      updateReport: vi.fn(),
+    };
+    const ctx = ctxWithStore(store, { approvalRequired: true, autoPublishOnApproval: false, approverAgentIds: ["agent-1"] });
+    const res = await route("/reports/:id/approve", "POST").handler({ params: { id: "rep_1" }, headers: { "x-fusion-actor-type": "agent", "x-fusion-user": "agent-2" } }, ctx as any) as any;
+    expect(res.status).toBe(403);
+  });
+
+  it("share-blocks returns 409 before approval and 200 after", async () => {
+    const current = makeReport({ approvalState: "awaiting_approval", combinedReview: { overallVerdict: "approve", consensusSummary: "ok", mergedHighlights: ["a"], mergedLowlights: [], mergedSuggestions: [], individual: [], failures: [] } });
+    const store = {
+      getReport: vi.fn(() => current),
+      updateReport: vi.fn(),
+    };
+    const ctx = ctxWithStore(store);
+    const locked = await route("/reports/:id/share-blocks", "GET").handler({ params: { id: "rep_1" } }, ctx as any) as any;
+    expect(locked.status).toBe(409);
+
+    const openStore = { ...store, getReport: vi.fn(() => ({ ...current, approvalState: "approved" as const })) };
+    const openCtx = ctxWithStore(openStore);
+    const open = await route("/reports/:id/share-blocks", "GET").handler({ params: { id: "rep_1" } }, openCtx as any) as any;
+    expect(open.status).toBe(200);
+    expect(open.body).toHaveProperty("plainText");
+  });
+});

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

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { aggregateReportData } from "../aggregation.js";
+import { resolveEnabledCadences } from "../cadence.js";
+import { startReportsPipeline } from "../pipeline.js";
+import { createInMemoryReportsRunsStore } from "../runs-store.js";
+
+describe("reports scaffold seams", () => {
+  it("resolves daily and weekly cadence by default in UTC", () => {
+    expect(resolveEnabledCadences({})).toEqual([
+      { cadence: "daily", timezone: "UTC" },
+      { cadence: "weekly", timezone: "UTC" },
+    ]);
+  });
+
+  it("resolves weekly-only cadence with configured timezone", () => {
+    expect(
+      resolveEnabledCadences({ dailyEnabled: false, weeklyEnabled: true, timezone: "America/Los_Angeles" }),
+    ).toEqual([{ cadence: "weekly", timezone: "America/Los_Angeles" }]);
+  });
+
+  it("returns empty sections from scaffold aggregator", async () => {
+    const output = await aggregateReportData({ runId: "run-1", cadence: "daily", settings: {} });
+    expect(output.sections).toEqual([]);
+  });
+
+  it("runs pipeline to review status on happy path", async () => {
+    const runsStore = createInMemoryReportsRunsStore();
+    const result = await startReportsPipeline(
+      { runId: "run-1", cadence: "daily", settings: {} },
+      { runsStore, aggregate: aggregateReportData },
+    );
+
+    expect(result.status).toBe("review");
+    const stored = await runsStore.get("run-1");
+    expect(stored).toEqual(result);
+    expect(stored?.cadence).toBe("daily");
+  });
+
+  it("marks pipeline run failed when aggregation throws and does not rethrow", async () => {
+    const runsStore = createInMemoryReportsRunsStore();
+    const result = await startReportsPipeline(
+      { runId: "run-2", cadence: "weekly", settings: {} },
+      {
+        runsStore,
+        aggregate: async () => {
+          throw new Error("boom");
+        },
+      },
+    );
+
+    expect(result.status).toBe("failed");
+    expect(result.error).toBe("boom");
+    await expect(runsStore.get("run-2")).resolves.toEqual(result);
+  });
+
+  it("returns undefined when updating unknown run", async () => {
+    const runsStore = createInMemoryReportsRunsStore();
+    await expect(runsStore.update("missing", { status: "failed" })).resolves.toBeUndefined();
+  });
+});

package/dist/plugins/fusion-plugin-reports/src/__tests__/share-blocks.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from "vitest";
+import { buildShareBlocks } from "../share-blocks.js";
+import type { Report } from "../store/report-types.js";
+
+function makeReport(): Report {
+  return {
+    id: "rep_1",
+    cadence: "weekly",
+    periodStart: "2026-05-01",
+    periodEnd: "2026-05-07",
+    title: "Weekly <Report> & \"Status\"",
+    status: "published",
+    generationStartedAt: "2026-05-01T00:00:00.000Z",
+    generationCompletedAt: null,
+    reviewStartedAt: null,
+    reviewCompletedAt: null,
+    approvedAt: null,
+    approvedBy: null,
+    publishedAt: null,
+    archivedAt: null,
+    failureReason: null,
+    approvalState: "published",
+    approvalHistory: [],
+    draftMarkdown: null,
+    renderedHtmlPath: null,
+    renderedHtml: null,
+    renderedHtmlGeneratedAt: null,
+    metadata: {},
+    combinedReview: {
+      overallVerdict: "approve",
+      consensusSummary: "ok",
+      mergedHighlights: ["Win <script>alert(1)</script>", "Win 2"],
+      mergedLowlights: ["Low & bad"],
+      mergedSuggestions: ["Do \"x\""],
+      individual: [],
+      failures: [],
+    },
+    createdAt: "2026-05-01T00:00:00.000Z",
+    updatedAt: "2026-05-01T00:00:00.000Z",
+  };
+}
+
+describe("buildShareBlocks", () => {
+  it("builds deterministic outputs", () => {
+    const report = makeReport();
+    const first = buildShareBlocks(report);
+    const second = buildShareBlocks(report);
+    expect(first).toEqual(second);
+    expect(first.markdown).toContain("## Weekly \\\<Report\\\>");
+    expect(first.slack).toContain("*Weekly <Report> & \"Status\"*");
+  });
+
+  it("escapes markdown and html", () => {
+    const blocks = buildShareBlocks(makeReport());
+    expect(blocks.markdown).toContain("\\<Report\\>");
+    expect(blocks.emailHtml).toContain("&lt;script&gt;alert(1)&lt;/script&gt;");
+    expect(blocks.emailHtml).toContain("&amp;");
+    expect(blocks.emailHtml).toContain("&quot;Status&quot;");
+  });
+
+  it("omits empty sections", () => {
+    const report = makeReport();
+    report.combinedReview = {
+      overallVerdict: "approve",
+      consensusSummary: "ok",
+      mergedHighlights: [],
+      mergedLowlights: [],
+      mergedSuggestions: [],
+      individual: [],
+      failures: [],
+    };
+    const blocks = buildShareBlocks(report);
+    expect(blocks.plainText).not.toContain("Wins:");
+    expect(blocks.markdown).not.toContain("### Wins");
+  });
+
+  it("slack block avoids markdown-only constructs", () => {
+    const blocks = buildShareBlocks(makeReport());
+    expect(blocks.slack).not.toContain("#");
+    expect(blocks.slack).not.toContain("**");
+    expect(blocks.slack).not.toContain("- ");
+  });
+});