@runfusion/fusion 0.23.0 → 0.25.0

package/dist/plugins/fusion-plugin-reports/src/review-panel.ts

@@ -0,0 +1,294 @@
+import type { CreateAiSessionFactory, PluginContext } from "@fusion/core";
+import { DEFAULT_REVIEW_PROMPT } from "./settings.js";
+import type {
+  CombinedReview,
+  IndividualReview,
+  ReviewFailure,
+  ReviewPanelMember,
+  ReviewVerdict,
+  RunReviewPanelInput,
+} from "./review-types.js";
+import { ReviewPanelError, ReviewParseError, ReviewTimeoutError } from "./review-types.js";
+
+let injectedCreateAiSession: CreateAiSessionFactory | undefined;
+
+const MAX_PARSE_RETRIES = 1;
+const MAX_MERGED_ITEMS = 25;
+export const REVIEW_TIMEOUT_MS = 120_000;
+
+interface AgentMessage {
+  role: string;
+  content?: string | Array<{ type: string; text: string }>;
+}
+
+function pickFactory(ctx: PluginContext): CreateAiSessionFactory | undefined {
+  return injectedCreateAiSession ?? ctx.createAiSession;
+}
+
+function getReviewPromptTemplate(reviewerId: string, settings: Record<string, unknown>): string {
+  const templates = settings.reviewPromptTemplates;
+  if (templates && typeof templates === "object" && !Array.isArray(templates)) {
+    const candidate = (templates as Record<string, unknown>)[reviewerId];
+    if (typeof candidate === "string" && candidate.trim()) return candidate.trim();
+  }
+  const reviewPrompt = settings.reviewPrompt;
+  if (typeof reviewPrompt === "string" && reviewPrompt.trim()) return reviewPrompt.trim();
+  return DEFAULT_REVIEW_PROMPT;
+}
+
+function buildSystemPrompt(member: ReviewPanelMember, settings: Record<string, unknown>): string {
+  const templateId = member.promptTemplateId ?? member.id;
+  const template = getReviewPromptTemplate(templateId, settings);
+  return `${template}\n\nReviewer perspective: ${member.perspective}`;
+}
+
+function extractJsonCandidate(text: string): string | null {
+  if (!text || !text.trim()) return null;
+  const codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+  const source = codeBlockMatch?.[1]?.trim() ?? text.trim();
+
+  const startIndex = source.indexOf("{");
+  if (startIndex < 0) return null;
+
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let index = startIndex; index < source.length; index++) {
+    const char = source[index];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') inString = false;
+      continue;
+    }
+
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+
+    if (char === "{") depth++;
+    if (char === "}") {
+      depth--;
+      if (depth === 0) return source.slice(startIndex, index + 1).trim();
+    }
+  }
+
+  return source.slice(startIndex).trim();
+}
+
+function asStringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item): item is string => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+}
+
+function parseReviewPayload(text: string): Omit<IndividualReview, "memberId" | "memberName" | "perspective" | "durationMs" | "rawText"> {
+  const candidate = extractJsonCandidate(text);
+  if (!candidate) throw new ReviewParseError("No JSON object found in reviewer response");
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(candidate);
+  } catch {
+    throw new ReviewParseError("Reviewer response is not valid JSON");
+  }
+
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new ReviewParseError("Reviewer response must be a JSON object");
+  }
+
+  const row = parsed as Record<string, unknown>;
+  const verdict = row.verdict;
+  const summary = row.summary;
+  if (verdict !== "approve" && verdict !== "revise" && verdict !== "reject") {
+    throw new ReviewParseError("Reviewer verdict must be approve, revise, or reject");
+  }
+  if (typeof summary !== "string" || !summary.trim()) {
+    throw new ReviewParseError("Reviewer summary must be a non-empty string");
+  }
+
+  return {
+    verdict,
+    summary: summary.trim(),
+    highlights: asStringArray(row.highlights),
+    lowlights: asStringArray(row.lowlights),
+    suggestions: asStringArray(row.suggestions),
+  };
+}
+
+function getAssistantText(messages: AgentMessage[]): string {
+  const lastMessage = messages.filter((message) => message.role === "assistant").pop();
+  if (!lastMessage?.content) return "";
+  if (typeof lastMessage.content === "string") return lastMessage.content;
+  return lastMessage.content
+    .filter((chunk): chunk is { type: "text"; text: string } => chunk.type === "text")
+    .map((chunk) => chunk.text)
+    .join("");
+}
+
+function toFailure(memberId: string, error: unknown): ReviewFailure {
+  if (error instanceof ReviewTimeoutError) {
+    return { memberId, reason: "timeout", message: error.message };
+  }
+  if (error instanceof ReviewParseError) {
+    return { memberId, reason: "parse_error", message: error.message };
+  }
+  if (error instanceof ReviewPanelError && error.reason === "session_unavailable") {
+    return { memberId, reason: "session_unavailable", message: error.message };
+  }
+  return {
+    memberId,
+    reason: "exception",
+    message: error instanceof Error ? error.message : String(error),
+  };
+}
+
+function timeoutAfter(ms: number, memberName: string): Promise<never> {
+  return new Promise((_, reject) => {
+    globalThis.setTimeout(() => {
+      reject(new ReviewTimeoutError(`Review timed out for ${memberName} after ${ms}ms`));
+    }, ms);
+  });
+}
+
+function dedupeMerged(items: string[]): string[] {
+  const seen = new Set<string>();
+  const merged: string[] = [];
+  for (const item of items) {
+    const trimmed = item.trim();
+    if (!trimmed) continue;
+    const key = trimmed.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(trimmed);
+    if (merged.length >= MAX_MERGED_ITEMS) break;
+  }
+  return merged;
+}
+
+function getVerdictRank(verdict: ReviewVerdict): number {
+  if (verdict === "reject") return 2;
+  if (verdict === "revise") return 1;
+  return 0;
+}
+
+export function combineReviews(individual: IndividualReview[], failures: ReviewFailure[]): CombinedReview {
+  if (individual.length === 0) {
+    return {
+      overallVerdict: "reject",
+      consensusSummary: "Review panel could not produce feedback because all reviewers failed.",
+      mergedHighlights: [],
+      mergedLowlights: [],
+      mergedSuggestions: [],
+      individual,
+      failures,
+    };
+  }
+
+  const worstVerdict = individual.reduce<ReviewVerdict>((current, review) =>
+    getVerdictRank(review.verdict) > getVerdictRank(current) ? review.verdict : current,
+  "approve");
+
+  const consensusSummary = individual
+    .map((review) => `${review.perspective}: ${review.summary}`)
+    .join(" | ");
+
+  return {
+    overallVerdict: worstVerdict,
+    consensusSummary,
+    mergedHighlights: dedupeMerged(individual.flatMap((review) => review.highlights)),
+    mergedLowlights: dedupeMerged(individual.flatMap((review) => review.lowlights)),
+    mergedSuggestions: dedupeMerged(individual.flatMap((review) => review.suggestions)),
+    individual,
+    failures,
+  };
+}
+
+async function runSingleReview(member: ReviewPanelMember, input: RunReviewPanelInput, createAiSession: CreateAiSessionFactory, settings: Record<string, unknown>): Promise<IndividualReview> {
+  const startedAt = Date.now();
+  const userPrompt = [
+    "Review the following generated report draft.",
+    "Return only strict JSON with keys: verdict, summary, highlights, lowlights, suggestions.",
+    "Do not include markdown fences or extra commentary.",
+    "",
+    `reportId: ${input.reportMetadata.reportId}`,
+    `cadence: ${input.reportMetadata.cadence}`,
+    `periodStart: ${input.reportMetadata.periodStart}`,
+    `periodEnd: ${input.reportMetadata.periodEnd}`,
+    "",
+    "reportDraft:",
+    input.reportDraft,
+  ].join("\n");
+
+  const response = await Promise.race([
+    (async () => {
+      const agent = await createAiSession({
+        cwd: input.cwd,
+        systemPrompt: buildSystemPrompt(member, settings),
+        tools: "readonly",
+        ...(member.provider && member.modelId ? { defaultProvider: member.provider, defaultModelId: member.modelId } : {}),
+      });
+
+      try {
+        await agent.session.prompt(userPrompt);
+        let text = getAssistantText(agent.session.state.messages as AgentMessage[]);
+
+        let parsed: Omit<IndividualReview, "memberId" | "memberName" | "perspective" | "durationMs" | "rawText"> | undefined;
+        let lastParseError: Error | undefined;
+        for (let attempt = 0; attempt <= MAX_PARSE_RETRIES; attempt++) {
+          try {
+            parsed = parseReviewPayload(text);
+            break;
+          } catch (error) {
+            lastParseError = error instanceof Error ? error : new Error(String(error));
+            if (attempt === MAX_PARSE_RETRIES) break;
+            await agent.session.prompt("Your previous response was not valid JSON. Respond with only a valid JSON object.");
+            text = getAssistantText(agent.session.state.messages as AgentMessage[]);
+          }
+        }
+
+        if (!parsed) {
+          throw new ReviewParseError(`Failed to parse reviewer response: ${lastParseError?.message ?? "unknown error"}`);
+        }
+
+        return {
+          memberId: member.id,
+          memberName: member.name,
+          perspective: member.perspective,
+          rawText: text,
+          durationMs: Date.now() - startedAt,
+          ...parsed,
+        };
+      } finally {
+        (agent.session as { dispose?: () => void }).dispose?.();
+      }
+    })(),
+    timeoutAfter(REVIEW_TIMEOUT_MS, member.name),
+  ]);
+
+  return response;
+}
+
+export async function runReviewPanel(input: RunReviewPanelInput, ctx: PluginContext): Promise<CombinedReview> {
+  const createAiSession = pickFactory(ctx);
+  if (!createAiSession) {
+    throw new ReviewPanelError("session_unavailable", "AI session factory is unavailable");
+  }
+
+  const settled = await Promise.allSettled(input.panel.map((member) => runSingleReview(member, input, createAiSession, ctx.settings)));
+
+  const individual: IndividualReview[] = [];
+  const failures: ReviewFailure[] = [];
+  for (let index = 0; index < settled.length; index++) {
+    const result = settled[index];
+    const member = input.panel[index];
+    if (result.status === "fulfilled") individual.push(result.value);
+    else failures.push(toFailure(member.id, result.reason));
+  }
+
+  return combineReviews(individual, failures);
+}
+
+export function __setCreateAiSessionFactory(factory: CreateAiSessionFactory | undefined): void {
+  injectedCreateAiSession = factory;
+}

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

@@ -0,0 +1,75 @@
+export type ReviewVerdict = "approve" | "revise" | "reject";
+
+export interface ReviewPanelMember {
+  id: string;
+  name: string;
+  perspective: string;
+  promptTemplateId?: string;
+  provider?: string;
+  modelId?: string;
+}
+
+export interface IndividualReview {
+  memberId: string;
+  memberName: string;
+  perspective: string;
+  verdict: ReviewVerdict;
+  summary: string;
+  highlights: string[];
+  lowlights: string[];
+  suggestions: string[];
+  rawText: string;
+  durationMs: number;
+}
+
+export interface ReviewFailure {
+  memberId: string;
+  reason: "timeout" | "parse_error" | "session_unavailable" | "exception";
+  message: string;
+}
+
+export interface CombinedReview {
+  overallVerdict: ReviewVerdict;
+  consensusSummary: string;
+  mergedHighlights: string[];
+  mergedLowlights: string[];
+  mergedSuggestions: string[];
+  individual: IndividualReview[];
+  failures: ReviewFailure[];
+}
+
+export interface RunReviewPanelInput {
+  reportDraft: string;
+  reportMetadata: {
+    reportId: string;
+    cadence: "daily" | "weekly";
+    periodStart: string;
+    periodEnd: string;
+  };
+  panel: ReviewPanelMember[];
+  cwd: string;
+}
+
+export class ReviewPanelError extends Error {
+  constructor(
+    public readonly reason: "session_unavailable" | "exception",
+    message: string,
+  ) {
+    super(message);
+    this.name = "ReviewPanelError";
+  }
+}
+
+export class ReviewParseError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ReviewParseError";
+  }
+}
+
+export class ReviewTimeoutError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ReviewTimeoutError";
+  }
+}

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

@@ -0,0 +1,105 @@
+import type { PluginSettingSchema } from "@fusion/plugin-sdk";
+
+export const DEFAULT_DAILY_ENABLED = true;
+export const DEFAULT_DAILY_CRON = "0 8 * * *";
+export const DEFAULT_WEEKLY_ENABLED = true;
+export const DEFAULT_WEEKLY_CRON = "0 8 * * 1";
+export const DEFAULT_TIMEZONE = "UTC";
+export const DEFAULT_GENERATION_PROMPT_DAILY = "Summarize today's system activity with clear wins, highlights, lowlights, and proposals.";
+export const DEFAULT_GENERATION_PROMPT_WEEKLY = "Summarize this week's system activity trends, major outcomes, and actionable proposals.";
+export const DEFAULT_REVIEW_PROMPT = "Review this report for factual accuracy, clarity, and actionability. Provide concrete revision suggestions.";
+export const DEFAULT_REVIEW_MIN_APPROVALS = 1;
+export const DEFAULT_REVIEW_BLOCKING_MODE = "advisory";
+export const DEFAULT_SECTION_ORDER = ["wins", "highlights", "lowlights", "proposals", "deep-dives", "per-agent"];
+export const DEFAULT_ENABLED_SECTIONS = [...DEFAULT_SECTION_ORDER];
+export const DEFAULT_INCLUDE_SYSTEM_SUMMARY = true;
+export const DEFAULT_INCLUDE_PER_AGENT_SECTIONS = true;
+export const DEFAULT_BRAND_TITLE = "Fusion Activity Report";
+export const DEFAULT_THEME_MODE = "auto";
+export const DEFAULT_ACCENT_COLOR = "#5B8DEF";
+export const DEFAULT_APPROVAL_REQUIRED = false;
+export const DEFAULT_AUTO_PUBLISH_ON_APPROVAL = true;
+export const DEFAULT_PUBLISH_TARGETS: string[] = [];
+
+export const settingsSchema: Record<string, PluginSettingSchema> = {
+  dailyEnabled: { type: "boolean", label: "Enable Daily Reports", description: "Generate daily reports on schedule.", group: "Schedules", defaultValue: DEFAULT_DAILY_ENABLED },
+  dailyCron: { type: "string", label: "Daily Schedule (cron)", description: "Cron expression for daily report generation.", group: "Schedules", required: true, defaultValue: DEFAULT_DAILY_CRON },
+  weeklyEnabled: { type: "boolean", label: "Enable Weekly Reports", description: "Generate weekly reports on schedule.", group: "Schedules", defaultValue: DEFAULT_WEEKLY_ENABLED },
+  weeklyCron: { type: "string", label: "Weekly Schedule (cron)", description: "Cron expression for weekly report generation.", group: "Schedules", required: true, defaultValue: DEFAULT_WEEKLY_CRON },
+  timezone: { type: "string", label: "Timezone", description: "IANA timezone used for schedule evaluation.", group: "Schedules", required: true, defaultValue: DEFAULT_TIMEZONE },
+
+  generationPromptDaily: { type: "string", multiline: true, label: "Daily Generation Prompt", description: "Prompt template used to generate daily reports.", group: "Prompts", required: true, defaultValue: DEFAULT_GENERATION_PROMPT_DAILY },
+  generationPromptWeekly: { type: "string", multiline: true, label: "Weekly Generation Prompt", description: "Prompt template used to generate weekly reports.", group: "Prompts", required: true, defaultValue: DEFAULT_GENERATION_PROMPT_WEEKLY },
+  reviewPrompt: { type: "string", multiline: true, label: "Review Prompt", description: "Prompt template used by reviewer agents.", group: "Prompts", required: true, defaultValue: DEFAULT_REVIEW_PROMPT },
+
+  reviewPanelAgentIds: { type: "array", itemType: "string", label: "Reviewer Agent IDs", description: "Agent IDs allowed to review generated reports.", group: "Review Panel", defaultValue: [] },
+  reviewMinApprovals: { type: "number", label: "Minimum Approvals", description: "How many approvals are required from the review panel.", group: "Review Panel", defaultValue: DEFAULT_REVIEW_MIN_APPROVALS },
+  reviewBlockingMode: { type: "enum", enumValues: ["block", "advisory"], label: "Review Blocking Mode", description: "Choose whether failed review blocks publication.", group: "Review Panel", defaultValue: DEFAULT_REVIEW_BLOCKING_MODE },
+
+  sectionOrder: { type: "array", itemType: "string", label: "Section Order", description: "Ordered section IDs for report rendering.", group: "Sections", defaultValue: DEFAULT_SECTION_ORDER },
+  enabledSections: { type: "array", itemType: "string", label: "Enabled Sections", description: "Section IDs enabled for output.", group: "Sections", defaultValue: DEFAULT_ENABLED_SECTIONS },
+  includeSystemSummary: { type: "boolean", label: "Include System Summary", description: "Include top-level system summary in report output.", group: "Sections", defaultValue: DEFAULT_INCLUDE_SYSTEM_SUMMARY },
+  includePerAgentSections: { type: "boolean", label: "Include Per-Agent Sections", description: "Include per-agent detail sections.", group: "Sections", defaultValue: DEFAULT_INCLUDE_PER_AGENT_SECTIONS },
+
+  brandTitle: { type: "string", label: "Report Title", description: "Primary report title for branding.", group: "Branding", required: true, defaultValue: DEFAULT_BRAND_TITLE },
+  brandLogoUrl: { type: "string", label: "Logo URL", description: "Optional URL to a brand logo image.", group: "Branding" },
+  themeMode: { type: "enum", enumValues: ["light", "dark", "auto"], label: "Theme Mode", description: "Theme style for generated reports.", group: "Branding", defaultValue: DEFAULT_THEME_MODE },
+  accentColor: { type: "string", label: "Accent Color", description: "Accent color used in report styling.", group: "Branding", defaultValue: DEFAULT_ACCENT_COLOR },
+
+  approvalRequired: { type: "boolean", label: "Require Approval", description: "Require explicit approval before publishing.", group: "Approval Flow", defaultValue: DEFAULT_APPROVAL_REQUIRED },
+  autoPublishOnApproval: { type: "boolean", label: "Auto Publish on Approval", description: "Publish automatically after approval threshold is met.", group: "Approval Flow", defaultValue: DEFAULT_AUTO_PUBLISH_ON_APPROVAL },
+  approverAgentIds: { type: "array", itemType: "string", label: "Approver Agent IDs", description: "Agent IDs permitted to approve final publish.", group: "Approval Flow", defaultValue: [] },
+  publishTargets: { type: "array", itemType: "string", label: "Publish Targets", description: "Destinations to publish reports to (for example dashboard, html-export).", group: "Approval Flow", defaultValue: DEFAULT_PUBLISH_TARGETS },
+};
+
+function asString(settings: Record<string, unknown>, key: string): string | undefined {
+  const value = settings[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+
+function asBoolean(settings: Record<string, unknown>, key: string, fallback: boolean): boolean {
+  const value = settings[key];
+  return typeof value === "boolean" ? value : fallback;
+}
+
+function asNumber(settings: Record<string, unknown>, key: string, fallback: number): number {
+  const value = settings[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+function asStringArray(settings: Record<string, unknown>, key: string, fallback: string[]): string[] {
+  const value = settings[key];
+  if (!Array.isArray(value)) return [...fallback];
+  const normalized = value.filter((item): item is string => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+  return normalized.length > 0 ? normalized : [...fallback];
+}
+
+export function getDailyEnabled(settings: Record<string, unknown>): boolean { return asBoolean(settings, "dailyEnabled", DEFAULT_DAILY_ENABLED); }
+export function getDailyCron(settings: Record<string, unknown>): string { return asString(settings, "dailyCron") ?? DEFAULT_DAILY_CRON; }
+export function getWeeklyEnabled(settings: Record<string, unknown>): boolean { return asBoolean(settings, "weeklyEnabled", DEFAULT_WEEKLY_ENABLED); }
+export function getWeeklyCron(settings: Record<string, unknown>): string { return asString(settings, "weeklyCron") ?? DEFAULT_WEEKLY_CRON; }
+export function getTimezone(settings: Record<string, unknown>): string { return asString(settings, "timezone") ?? DEFAULT_TIMEZONE; }
+export function getGenerationPromptDaily(settings: Record<string, unknown>): string { return asString(settings, "generationPromptDaily") ?? DEFAULT_GENERATION_PROMPT_DAILY; }
+export function getGenerationPromptWeekly(settings: Record<string, unknown>): string { return asString(settings, "generationPromptWeekly") ?? DEFAULT_GENERATION_PROMPT_WEEKLY; }
+export function getReviewPrompt(settings: Record<string, unknown>): string { return asString(settings, "reviewPrompt") ?? DEFAULT_REVIEW_PROMPT; }
+export function getReviewPanelAgentIds(settings: Record<string, unknown>): string[] { return asStringArray(settings, "reviewPanelAgentIds", []); }
+export function getReviewMinApprovals(settings: Record<string, unknown>): number { return Math.max(1, Math.floor(asNumber(settings, "reviewMinApprovals", DEFAULT_REVIEW_MIN_APPROVALS))); }
+export function getReviewBlockingMode(settings: Record<string, unknown>): "block" | "advisory" {
+  const value = asString(settings, "reviewBlockingMode");
+  return value === "block" ? "block" : "advisory";
+}
+export function getSectionOrder(settings: Record<string, unknown>): string[] { return asStringArray(settings, "sectionOrder", DEFAULT_SECTION_ORDER); }
+export function getEnabledSections(settings: Record<string, unknown>): string[] { return asStringArray(settings, "enabledSections", DEFAULT_ENABLED_SECTIONS); }
+export function getIncludeSystemSummary(settings: Record<string, unknown>): boolean { return asBoolean(settings, "includeSystemSummary", DEFAULT_INCLUDE_SYSTEM_SUMMARY); }
+export function getIncludePerAgentSections(settings: Record<string, unknown>): boolean { return asBoolean(settings, "includePerAgentSections", DEFAULT_INCLUDE_PER_AGENT_SECTIONS); }
+export function getBrandTitle(settings: Record<string, unknown>): string { return asString(settings, "brandTitle") ?? DEFAULT_BRAND_TITLE; }
+export function getBrandLogoUrl(settings: Record<string, unknown>): string | undefined { return asString(settings, "brandLogoUrl"); }
+export function getThemeMode(settings: Record<string, unknown>): "light" | "dark" | "auto" {
+  const value = asString(settings, "themeMode");
+  return value === "light" || value === "dark" ? value : "auto";
+}
+export function getAccentColor(settings: Record<string, unknown>): string { return asString(settings, "accentColor") ?? DEFAULT_ACCENT_COLOR; }
+export function getApprovalRequired(settings: Record<string, unknown>): boolean { return asBoolean(settings, "approvalRequired", DEFAULT_APPROVAL_REQUIRED); }
+export function getAutoPublishOnApproval(settings: Record<string, unknown>): boolean { return asBoolean(settings, "autoPublishOnApproval", DEFAULT_AUTO_PUBLISH_ON_APPROVAL); }
+export function getApproverAgentIds(settings: Record<string, unknown>): string[] { return asStringArray(settings, "approverAgentIds", []); }
+export function getPublishTargets(settings: Record<string, unknown>): string[] { return asStringArray(settings, "publishTargets", DEFAULT_PUBLISH_TARGETS); }

package/dist/plugins/fusion-plugin-reports/src/store/__tests__/report-schema.test.ts

@@ -0,0 +1,66 @@
+import { Database } from "@fusion/core";
+import { mkdtempSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { ensureReportSchema } from "../../report-schema.js";
+
+function makeTmpDir(): string {
+  return mkdtempSync(join(tmpdir(), "report-schema-test-"));
+}
+
+describe("ensureReportSchema", () => {
+  let tmp: string;
+  let db: Database;
+
+  beforeEach(() => {
+    tmp = makeTmpDir();
+    db = new Database(join(tmp, ".fusion"), { inMemory: true });
+    db.init();
+  });
+
+  afterEach(async () => {
+    db.close();
+    await rm(tmp, { recursive: true, force: true });
+  });
+
+  it("creates reports table and indexes idempotently", () => {
+    ensureReportSchema(db);
+    ensureReportSchema(db);
+
+    const table = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='reports'").get() as { name: string } | undefined;
+    expect(table?.name).toBe("reports");
+
+    const indexes = db.prepare("SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='reports' ORDER BY name").all() as Array<{ name: string }>;
+    expect(indexes.map((row) => row.name)).toEqual(expect.arrayContaining([
+      "idxReportsCadenceCreated",
+      "idxReportsStatusUpdated",
+      "idxReportsPeriod",
+    ]));
+  });
+
+  it("enforces cadence and status CHECK constraints", () => {
+    ensureReportSchema(db);
+
+    const base = {
+      id: "rep_1",
+      cadence: "daily",
+      periodStart: "2026-05-08T00:00:00.000Z",
+      periodEnd: "2026-05-08T23:59:59.999Z",
+      title: "Daily Report",
+      status: "generating",
+      generationStartedAt: "2026-05-09T00:00:00.000Z",
+      createdAt: "2026-05-09T00:00:00.000Z",
+      updatedAt: "2026-05-09T00:00:00.000Z",
+    };
+
+    const stmt = db.prepare(`
+      INSERT INTO reports (id, cadence, periodStart, periodEnd, title, status, generationStartedAt, createdAt, updatedAt)
+      VALUES (@id, @cadence, @periodStart, @periodEnd, @title, @status, @generationStartedAt, @createdAt, @updatedAt)
+    `);
+
+    expect(() => stmt.run({ ...base, id: "rep_bad_cadence", cadence: "hourly" })).toThrow();
+    expect(() => stmt.run({ ...base, id: "rep_bad_status", status: "queued" })).toThrow();
+  });
+});