scenescout 3.21.3 → 3.22.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # scenescout
 
+## 3.22.0
+
+### Minor Changes
+
+- 072b68b: `scenescout check --record --template <file.json>` (the action's `template` input) also writes the recorded run up as a test report laid out by the template: each saved flow a test and each step a row with its expected and actual result and its frame, failed steps as deviations, a SHA-256 manifest of the evidence and blank sign-off rows. Flows gain optional `id`, `requirements` and a step's `expected` for traceability; an example template is in `examples/report-template.json`.
+
 ## 3.21.3
 
 ### Patch Changes

package/README.md

@@ -279,7 +279,10 @@ Use SceneScout to test http://localhost:3000, record the run
 or, on the tool directly, `scout_attach {record: true}`. `SCENESCOUT_RECORD=on` in
 the server's environment records every run. A CI gate records too:
 `scenescout check --record` writes `replay.html`, every journey step by step with
-its frames ([recording a check](docs/ci.md#recording-a-check)).
+its frames ([recording a check](docs/ci.md#recording-a-check)), and
+`--template <file.json>` also writes it up as a test report laid out as a template
+says, with expected and actual results, deviations, blank sign-off rows and a
+SHA-256 manifest of the evidence ([test reports](docs/ci.md#a-test-report-from-a-template)).
 
 Then `scout_report` writes two files side by side in `.scenescout/`:
 `report.md` as always, and `report.html` — the whole run as one self-contained

package/dist/check-run.js

@@ -20,6 +20,7 @@ import { firstLineOf } from "./engine/limits.js";
 import { isNonPageResource } from "./engine/crawl.js";
 import { checkRetestPlan, retestResults, wellFormedFindings } from "./engine/verify.js";
 import { capFrames, isReplayFrameFile, journeyOf, journeyVideoPath, isGeneratedReplay, isJourneyVideoFile, redactReplay, REPLAY_VIDEOS_DIRNAME, replayVideos, REPLAY_FILE, REPLAY_FRAMES_DIRNAME, replayFramePath, replayFrames, replaySessionKey, visitOf, } from "./engine/check-replay.js";
+import { buildTemplateReport, evidenceFiles, evidenceIndex, isGeneratedReport, readReportTemplate, recordedReportFile, reportFileOf, templateRecordError, } from "./engine/check-report.js";
 /** The baselines folder a check uses: the one --baselines names, else the project's own. */
 export function baselinesDirOf(options) {
     return options.baselinesDir ?? defaultBaselinesDir(options.projectDir);
@@ -470,7 +471,34 @@ async function takeBaselines(engine, options, mode, targets, log) {
  * check, recorded or not, so a page from an earlier run is never read, or
  * uploaded, as this one's; whatever else the folder holds stays.
  */
-export function clearReplayOutput(outDir) {
+export function clearReplayOutput(outDir, reportFile) {
+    // The test report the earlier run's check.json says it wrote (--template), and the one this run's template names:
+    // each only when it still carries the mark. A copy renamed or kept under any other name is the project's own.
+    const reports = new Set();
+    try {
+        const earlier = recordedReportFile(JSON.parse(fs.readFileSync(path.join(outDir, "check.json"), "utf8")));
+        if (earlier)
+            reports.add(earlier);
+    }
+    catch {
+        // No earlier check.json, or one that cannot be read: it names no report to remove.
+    }
+    if (reportFile)
+        reports.add(reportFile);
+    for (const name of reports) {
+        const at = path.join(outDir, name);
+        let text;
+        try {
+            text = fs.readFileSync(at, "utf8");
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                continue;
+            throw err;
+        }
+        if (isGeneratedReport(text))
+            fs.rmSync(at);
+    }
     // Only a page a check wrote: a file of the same name the project keeps there is its own.
     const page = path.join(outDir, REPLAY_FILE);
     let text = null;
@@ -512,6 +540,39 @@ export function clearReplayOutput(outDir) {
     if (fs.readdirSync(root).length === 0)
         fs.rmdirSync(root);
 }
+/**
+ * The report template a check was given (--template), read and validated, or
+ * null for none. Throws, before the browser starts, when the check is not
+ * recorded, when the template is not valid, or when the file it would write is
+ * one the project keeps there and a check did not write.
+ */
+export function prepareTemplateReport(options, outDir) {
+    if (options.template === undefined)
+        return null;
+    const needsRecord = templateRecordError(options);
+    if (needsRecord)
+        throw new Error(needsRecord);
+    const template = readReportTemplate(options.template);
+    const file = path.join(outDir, reportFileOf(template));
+    let text = null;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+    if (text !== null && !isGeneratedReport(text))
+        throw new Error(`${file} is not a report SceneScout wrote, so a check will not overwrite it. Move or rename it, name another file in the template's "file", or pass --out to write the check somewhere else`);
+    return template;
+}
+/** Write the template's report beside replay.html, after check.json and the replay page, so the manifest hashes the files as written. Returns its file name. */
+export function writeTemplateReport(outDir, result, template, meta) {
+    const file = reportFileOf(template);
+    const evidence = evidenceIndex(outDir, evidenceFiles(result));
+    fs.writeFileSync(path.join(outDir, file), buildTemplateReport(result, template, evidence, meta));
+    return file;
+}
 /**
  * Why a recorded check (--record or --video) must not start, or null: a
  * replay.html in the output folder that a check did not write is the

package/dist/cli.js

@@ -21,7 +21,8 @@ import { APPROX_DISK_MB, defaultAttachNote, defaultEngine, launchTarget, parseBr
 import { CLIENT_LABELS, firstMessageHint, manualFor, parseClients, registerWithClient, vscodeBinary } from "./clients.js";
 import { CLAUDE_CODE_NOT_NEEDED, CLI_NAME, desktopExtensionRoots, diagnose, doctorAllGood, findDesktopExtension, installClosing, ensureCommand, findOnUserPath, installSkill, isEphemeralRoot, launchCommand, manualRegisterCommand, planCommand, registerMcp, resolveClaudeDir, spawnRunner, } from "./installer.js";
 import { downloadBrowsers, presentBrowsers } from "./installer.js";
-import { baselinesDirOf, clearReplayOutput, replayPageConflict, defaultCheckDir, readCheckInputs, runCheck } from "./check-run.js";
+import { baselinesDirOf, clearReplayOutput, replayPageConflict, defaultCheckDir, prepareTemplateReport, readCheckInputs, runCheck, writeTemplateReport, } from "./check-run.js";
+import { reportFileOf } from "./engine/check-report.js";
 import { buildCheckReplayHtml, commitOf, REPLAY_FILE, replayFrames, replayVideos } from "./engine/check-replay.js";
 import { recordChoice } from "./engine/capture.js";
 import { httpClient, httpJudgeAsk, runCi } from "./ci-run.js";
@@ -112,7 +113,10 @@ Usage:
                                       and write replay.html beside the report, role → journey → step (default:
                                       SCENESCOUT_RECORD, else off; the frames go in replay-frames/);
                                      --video [on|off]: record a WebM of each saved flow, and only of the flows,
-                                      into replay-videos/, played on replay.html beside its steps (default off))
+                                      into replay-videos/, played on replay.html beside its steps (default off);
+                                     --template file.json: on a recorded check, also write a test report laid out
+                                      as the template says (report.html unless it names a file), with the frames,
+                                      deviations and a SHA-256 manifest of the evidence; needs --record)
                                     Exit code: 0 passed, 1 failed the gate, 2 could not run.
   scenescout ci <url>               An exploratory run with no person present: a model reached through its API
                                     drives the tools by the SceneScout method and the run ends in the report.
@@ -580,15 +584,18 @@ async function check(args) {
     let options = parsed.options;
     const outDir = options.outDir ?? defaultCheckDir(options.projectDir);
     let inputs;
+    let template = null;
     try {
         // --record, else SCENESCOUT_RECORD, else off.
         options = { ...options, record: recordChoice(options.record, process.env) };
+        // --template: read and checked before the browser starts, so a bad template never costs a run.
+        template = prepareTemplateReport(options, outDir);
         // A replay.html the project keeps there is its own: a recorded check refuses to start rather than overwrite it.
         const conflict = options.record || options.video ? replayPageConflict(outDir) : null;
         if (conflict)
             throw new Error(conflict);
         // A replay page an earlier run left must never be read, or uploaded, as this run's.
-        clearReplayOutput(outDir);
+        clearReplayOutput(outDir, template ? reportFileOf(template) : undefined);
         inputs = readCheckInputs(options);
     }
     catch (err) {
@@ -615,7 +622,11 @@ async function check(args) {
         console.error(`scenescout check: could not run a saved flow: ${refused}`);
         process.exit(EXIT.error);
     }
+    // Recorded in check.json, so the next check removes exactly this file and the action finds it.
+    if (template && result.replay)
+        result = { ...result, testReport: reportFileOf(template) };
     const markdown = formatCheck(result);
+    let reportFile = null;
     try {
         const version = packageVersion();
         if (!options.outDir)
@@ -645,6 +656,8 @@ async function check(args) {
                 couldNotRun,
             });
             fs.writeFileSync(path.join(outDir, REPLAY_FILE), html);
+            if (template)
+                reportFile = writeTemplateReport(outDir, result, template, { version, commit: commitOf(process.env) });
         }
         // On GitHub Actions the verdict also goes on the run's summary page.
         if (process.env.GITHUB_STEP_SUMMARY)
@@ -659,6 +672,8 @@ async function check(args) {
     console.log(`Wrote report.md, check.sarif and check.json to ${outDir}`);
     if (result.replay)
         console.log(`Wrote ${REPLAY_FILE} to ${outDir}, with ${replayFrames(result.replay).length} frame(s) and ${replayVideos(result.replay).length} journey video(s) beside it: open it in a browser to see each step`);
+    if (reportFile)
+        console.log(`Wrote ${reportFile} to ${outDir}: the test report the template lays out, with a SHA-256 manifest of its evidence`);
     const pictured = result.baselines?.results.filter((r) => r.files).length ?? 0;
     if (pictured > 0)
         console.log(`Wrote the pictures of ${pictured} changed baseline(s) under ${path.join(outDir, VISUAL_DIRNAME)}`);

package/dist/engine/check-replay.js

@@ -33,6 +33,12 @@ function shotFields(shot) {
         return { frame: shot.frame };
     return shot?.pastCap ? { pastCap: true } : {};
 }
+/** What a step should bring about: its own `expected`, else an expect-* step's assertion, else nothing. */
+export function expectedOf(step) {
+    if (step.expected !== undefined)
+        return step.expected;
+    return step.action.startsWith("expect-") ? describeStep(step) : undefined;
+}
 /**
  * Each step of a replayed flow with its caption, its result and its frame.
  * The replay stops at the first step that breaks, so every step before it
@@ -44,11 +50,12 @@ export function journeySteps(steps, outcome, frames = []) {
     return steps.map((step, i) => {
         const n = i + 1;
         const shot = broke === null || n <= broke ? shotFields(frames[i]) : {};
-        const base = { n, caption: describeStep(step), ...shot };
+        const expected = expectedOf(step);
+        const base = { n, caption: describeStep(step), ...(expected !== undefined ? { expected } : {}), ...shot };
         if (broke === null || n < broke)
             return { ...base, result: "passed" };
         if (n > broke)
-            return { n, caption: base.caption, result: "not-run" };
+            return { n, caption: base.caption, ...(expected !== undefined ? { expected } : {}), result: "not-run" };
         // `broke` is set only when the outcome is not "passed".
         const failed = outcome;
         return { ...base, result: failed.status, reason: failed.reason, path: failed.path };
@@ -59,6 +66,8 @@ export function journeyOf(flow, outcome, frames) {
     return {
         name: flow.name,
         file: flow.file,
+        ...(flow.id !== undefined ? { id: flow.id } : {}),
+        ...(flow.requirements !== undefined ? { requirements: [...flow.requirements] } : {}),
         status: outcome.status,
         steps: journeySteps(flow.steps, outcome, frames),
         ...(outcome.status === "passed" ? {} : { firstFailing: outcome.step }),
@@ -119,6 +128,7 @@ export function redactReplay(replay) {
                 steps: j.steps.map((s) => ({
                     ...s,
                     caption: redactRoute(s.caption),
+                    ...(s.expected !== undefined ? { expected: redactRoute(s.expected) } : {}),
                     ...(s.reason !== undefined ? { reason: redactRoute(s.reason) } : {}),
                     ...(s.path !== undefined ? { path: redactRoute(s.path) } : {}),
                 })),

package/dist/engine/check-report.js

@@ -0,0 +1,503 @@
+/**
+ * The template-driven test report of a recorded `scenescout check`
+ * (`--record --template <file.json>`): the same run the replay page shows, laid
+ * out as a document a reviewer signs off on paper or in their own system.
+ *
+ * The template decides the layout only: the title block, the document ID, the
+ * order of the sections, the columns of the test table, the sign-off roles,
+ * free text and every word the page uses. The data is the run's: each saved
+ * flow is a test, each of its steps a row, and a step's result comes from the
+ * replay's assertions alone, never from a model. A step that failed or was
+ * refused is a deviation. The manifest lists the SHA-256 of every evidence
+ * file, so a reader can tell the frames and videos beside the report are the
+ * ones the run wrote.
+ *
+ * Everything here but readReportTemplate and evidenceIndex is pure: the same
+ * result, template and evidence render the same bytes (a golden file in
+ * scripts/report-test.ts holds that). check-run.ts reads the files and writes the page.
+ */
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { REPLAY_FILE, replayFrames, replayVideos } from "./check-replay.js";
+import { summarise } from "./check.js";
+import { parseJsonFile } from "./flow.js";
+import { escapeHtml } from "./replay.js";
+/** The page's generator mark: an earlier run's report is removed or replaced only when it carries it. */
+export const REPORT_GENERATOR = "scenescout-check-report";
+/** The file the report is written to when the template names none. */
+export const DEFAULT_REPORT_FILE = "report.html";
+/** What the cell of a missing value shows. */
+export const MISSING = "—";
+/** A report's file name: plain, in the output folder itself, ending .html. */
+export const REPORT_FILE_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}\.html$/;
+/** A name Windows reserves for a device whatever its extension (CON.html opens the console): never a report's file. */
+export const WINDOWS_DEVICE_RE = /^(con|prn|aux|nul|com[0-9]|lpt[0-9])\./i;
+/** Whether a name may be a report's file: plain, ending .html, not replay.html and not a Windows device name. */
+export function isReportFileName(name) {
+    return REPORT_FILE_RE.test(name) && !WINDOWS_DEVICE_RE.test(name) && name.toLowerCase() !== REPLAY_FILE;
+}
+/**
+ * The report file an earlier check.json records it wrote (its `testReport`),
+ * or null: anything that is not a plain report file name is ignored, so the
+ * value can never point outside the output folder or at the replay page.
+ */
+export function recordedReportFile(checkJson) {
+    if (typeof checkJson !== "object" || checkJson === null)
+        return null;
+    const file = checkJson.testReport;
+    return typeof file === "string" && isReportFileName(file) ? file : null;
+}
+/** Whether an HTML file is a report a check wrote. */
+export function isGeneratedReport(html) {
+    return html.includes(`<meta name="generator" content="${REPORT_GENERATOR}">`);
+}
+// ── the template ────────────────────────────────────────────────────────────
+/** The columns a test table may have, in any order. */
+export const REPORT_COLUMNS = ["testId", "requirements", "step", "expected", "actual", "result", "evidence"];
+/** The sections a template may order. Each data section appears at most once; `text` as often as wanted. */
+export const REPORT_SECTIONS = ["summary", "tests", "deviations", "manifest", "signoff", "text"];
+/** The tokens the title block may use, each replaced by a fact of the run. */
+export const REPORT_TOKENS = {
+    date: "the day the run started, YYYY-MM-DD (UTC)",
+    time: "the time the run started, HH:MM:SS (UTC)",
+    run: "the run's start as YYYYMMDD-HHMMSS (UTC)",
+    version: "the SceneScout version",
+    commit: "the commit the run was of (GITHUB_SHA), shortened to 12 characters, or — when none",
+};
+/** Every word the page writes that is not data. A template may replace any of them, so it carries its own vocabulary. */
+export const DEFAULT_LABELS = {
+    pass: "Pass",
+    fail: "Fail",
+    refused: "Could not run",
+    notRun: "Not run",
+    asExpected: "As expected",
+    summary: "Summary",
+    tests: "Test results",
+    deviations: "Deviations",
+    manifest: "Evidence manifest",
+    signoff: "Sign-off",
+    testId: "Test ID",
+    requirements: "Requirements",
+    step: "Step",
+    expected: "Expected result",
+    actual: "Actual result",
+    result: "Result",
+    evidence: "Evidence",
+    frame: "Frame after the step",
+    video: "Video",
+    test: "Test",
+    number: "#",
+    noDeviations: "No deviations.",
+    noTests: "No saved flow ran.",
+    overall: "Overall result",
+    target: "Target",
+    started: "Started",
+    ended: "Ended",
+    tool: "SceneScout version",
+    commit: "Commit",
+    testsRun: "Tests",
+    testsPassed: "Passed",
+    testsFailed: "Failed",
+    testsNotRun: "Could not run",
+    gateIssues: "Issues failing the check's gate",
+    file: "File",
+    bytes: "Bytes",
+    sha256: "SHA-256",
+    notFound: "not found",
+    name: "Name",
+    role: "Role",
+    signature: "Signature",
+    signedDate: "Date",
+    meaning: "Meaning of signature",
+    documentId: "Document ID",
+};
+const text = (what, max) => z.string().trim().min(1, `is ${what}`).max(max, `is at most ${max} characters`);
+const TOKEN_RE = /\{([^{}]*)\}/g;
+/** Text that may use the title block's tokens: every `{…}` must name one. */
+const tokenText = (what, max) => text(what, max).superRefine((value, ctx) => {
+    for (const m of value.matchAll(TOKEN_RE)) {
+        if (!Object.hasOwn(REPORT_TOKENS, m[1]))
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `uses {${m[1]}}, which is not a token: use ${Object.keys(REPORT_TOKENS)
+                    .map((t) => `{${t}}`)
+                    .join(", ")}`,
+            });
+    }
+});
+const paragraphs = z.array(text("a paragraph of text", 4000)).max(50, "holds at most 50 paragraphs");
+const heading = text("the section's heading", 200);
+const columnSchema = z.union([z.enum(REPORT_COLUMNS), z.object({ key: z.enum(REPORT_COLUMNS), heading }).strict()], {
+    errorMap: () => ({ message: `must be one of ${REPORT_COLUMNS.join(", ")}, or { "key": one of those, "heading": "…" }` }),
+});
+const signoffRole = z.union([text("the role that signs", 200), z.object({ role: text("the role that signs", 200), meaning: text("what the signature means", 500).optional() }).strict()], {
+    errorMap: () => ({ message: 'must be the role that signs, e.g. "Reviewer", or { "role": "…", "meaning": "…" }' }),
+});
+const sectionSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("summary"), heading: heading.optional(), paragraphs: paragraphs.optional() }).strict(),
+    z
+        .object({
+        type: z.literal("tests"),
+        heading: heading.optional(),
+        paragraphs: paragraphs.optional(),
+        columns: z
+            .array(columnSchema)
+            .min(1, "needs at least one column")
+            .refine((cols) => new Set(cols.map((c) => (typeof c === "string" ? c : c.key))).size === cols.length, { message: "names a column twice" }),
+    })
+        .strict(),
+    z.object({ type: z.literal("deviations"), heading: heading.optional(), paragraphs: paragraphs.optional() }).strict(),
+    z.object({ type: z.literal("manifest"), heading: heading.optional(), paragraphs: paragraphs.optional() }).strict(),
+    z
+        .object({
+        type: z.literal("signoff"),
+        heading: heading.optional(),
+        paragraphs: paragraphs.optional(),
+        roles: z.array(signoffRole).min(1, "needs at least one role").max(20, "holds at most 20 roles"),
+    })
+        .strict(),
+    z.object({ type: z.literal("text"), heading: heading.optional(), paragraphs: paragraphs.min(1, "needs at least one paragraph") }).strict(),
+]);
+const labelsSchema = z
+    .object(Object.fromEntries(Object.keys(DEFAULT_LABELS).map((k) => [k, text("the word to use", 200).optional()])))
+    .strict();
+const templateSchema = z
+    .object({
+    /** The file name the report is written to, beside replay.html. */
+    file: z
+        .string()
+        .regex(REPORT_FILE_RE, "must be a plain file name ending .html, e.g. test-report.html")
+        .refine((f) => f.toLowerCase() !== REPLAY_FILE, { message: `must not be ${REPLAY_FILE}, which the replay page is written to` })
+        .refine((f) => !WINDOWS_DEVICE_RE.test(f), { message: "must not be a name Windows reserves for a device, such as CON.html or NUL.html" })
+        .optional(),
+    title: tokenText("the document's title", 300),
+    subtitle: tokenText("a line under the title", 300).optional(),
+    documentId: tokenText("the document ID pattern, e.g. TR-{run}", 200).optional(),
+    fields: z
+        .array(z.object({ label: text("the field's label", 200), value: tokenText("the field's value", 500) }).strict())
+        .max(20, "holds at most 20 fields")
+        .optional(),
+    labels: labelsSchema.optional(),
+    sections: z
+        .array(sectionSchema)
+        .min(1, "needs at least one section")
+        .max(50, "holds at most 50 sections")
+        .superRefine((sections, ctx) => {
+        const seen = new Set();
+        sections.forEach((s, i) => {
+            if (s.type !== "text" && seen.has(s.type))
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: [i, "type"],
+                    message: `"${s.type}" appears more than once: each section but text appears at most once`,
+                });
+            seen.add(s.type);
+        });
+    }),
+})
+    .strict();
+/** Validate a template's text. Every mistake names the file and the field, as a flow's do. */
+export function parseReportTemplate(raw, file) {
+    const parsed = parseJsonFile(raw, file, templateSchema);
+    if (!parsed.ok) {
+        // A section's discriminator is "type", not a flow's "action": say so in its own words.
+        return { ok: false, error: parsed.error.replace(/must be one of navigate, [^;]*/g, `must be one of ${REPORT_SECTIONS.join(", ")}`) };
+    }
+    return { ok: true, template: parsed.data };
+}
+/** Read and validate a template file, or throw a sentence naming it. */
+export function readReportTemplate(file) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (err) {
+        throw new Error(`--template: cannot read ${file} (${err instanceof Error ? err.message : String(err)})`);
+    }
+    const parsed = parseReportTemplate(raw, file);
+    if (!parsed.ok)
+        throw new Error(`--template: ${parsed.error}`);
+    return parsed.template;
+}
+/** The file the template's report is written to. */
+export function reportFileOf(template) {
+    return template.file ?? DEFAULT_REPORT_FILE;
+}
+/** Why --template cannot be used with these options, or null: the report renders a recorded run, so recording must be on. */
+export function templateRecordError(options) {
+    if (options.template === undefined || options.record === true)
+        return null;
+    return "--template renders the report from a recorded check's frames: add --record (or set SCENESCOUT_RECORD=on)";
+}
+/** The files a recorded check's report vouches for, in this order: check.json, the replay page, every frame and every video. */
+export function evidenceFiles(result) {
+    if (!result.replay)
+        return ["check.json"];
+    return ["check.json", REPLAY_FILE, ...replayFrames(result.replay), ...replayVideos(result.replay)];
+}
+/** Hash each file beside the report. A file that is not there is listed as missing rather than left out. */
+export function evidenceIndex(outDir, files) {
+    return files.map((rel) => {
+        try {
+            const data = fs.readFileSync(path.join(outDir, ...rel.split("/")));
+            return { path: rel, bytes: data.length, sha256: createHash("sha256").update(data).digest("hex") };
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return { path: rel, bytes: null, sha256: null };
+            throw err;
+        }
+    });
+}
+/** Every test in the order the replay shows them: the check's own session first, then each role. */
+function testsOf(result) {
+    return (result.replay?.roles ?? []).flatMap((r) => r.journeys.map((journey) => ({ journey, role: r.own ? null : r.role })));
+}
+function tokensOf(result, meta) {
+    const started = result.replay?.startedAt ?? result.generatedAt;
+    const date = started.slice(0, 10);
+    const time = started.slice(11, 19);
+    return {
+        date,
+        time,
+        run: `${date.replace(/-/g, "")}-${time.replace(/:/g, "")}`,
+        version: meta.version,
+        commit: meta.commit ? meta.commit.slice(0, 12) : MISSING,
+    };
+}
+function fill(value, tokens) {
+    return value.replace(TOKEN_RE, (whole, name) => (Object.hasOwn(tokens, name) ? tokens[name] : whole));
+}
+/** A UTC time as the page shows it. */
+function stamp(iso) {
+    return iso.length >= 19 ? `${iso.slice(0, 10)} ${iso.slice(11, 19)} UTC` : iso;
+}
+/** Escaped text, or the missing mark. */
+function cell(value) {
+    return value === undefined || value === null || value === "" ? MISSING : escapeHtml(value);
+}
+function resultWord(result, L) {
+    return result === "passed" ? L.pass : result === "failed" ? L.fail : result === "refused" ? L.refused : L.notRun;
+}
+/** What a step did, in words: as expected when it passed, why when it did not, nothing when it never ran. */
+function actualOf(step, L) {
+    if (step.result === "passed")
+        return L.asExpected;
+    if (step.result === "not-run")
+        return undefined;
+    return [step.reason, step.path ? `on ${step.path}` : ""].filter(Boolean).join(" ") || undefined;
+}
+function paragraphsHtml(list) {
+    return (list ?? []).map((p) => `<p>${escapeHtml(p)}</p>`).join("");
+}
+function sectionHead(section, fallback) {
+    return `<h2>${escapeHtml(section.heading ?? fallback)}</h2>${paragraphsHtml(section.paragraphs)}`;
+}
+function frameCellHtml(step, L) {
+    if (!step.frame)
+        return MISSING;
+    const src = escapeHtml(step.frame);
+    return `<a class="frame" href="${src}" target="_blank" rel="noreferrer" data-testid="report-frame-open"><img loading="lazy" src="${src}" alt="${escapeHtml(`${L.frame}: ${step.caption}`)}"><span>${escapeHtml(step.frame)}</span></a>`;
+}
+function summaryHtml(section, result, meta, L) {
+    const tests = testsOf(result);
+    const { passed, couldNotRun, failing } = summarise(result);
+    const count = (status) => tests.filter((t) => t.journey.status === status).length;
+    // A test that failed fails the report even when the gate let it through (--fail-on never): a pass here is a pass of every test.
+    const green = couldNotRun === 0 && passed && count("failed") === 0;
+    const overall = couldNotRun > 0 ? L.refused : green ? L.pass : L.fail;
+    const row = (term, value, cls = "") => `<tr${cls ? ` class="${cls}"` : ""}><th scope="row">${escapeHtml(term)}</th><td>${value}</td></tr>`;
+    const overallClass = green ? "pass" : "fail";
+    return (`<section class="summary" data-section="summary">${sectionHead(section, L.summary)}<table class="facts">` +
+        row(L.overall, `<span class="verdict ${overallClass}" data-testid="report-verdict">${escapeHtml(overall)}</span>`) +
+        row(L.target, cell(result.url)) +
+        row(L.started, cell(stamp(result.replay?.startedAt ?? result.generatedAt))) +
+        row(L.ended, cell(stamp(result.generatedAt))) +
+        row(L.tool, cell(meta.version)) +
+        row(L.commit, cell(meta.commit)) +
+        row(L.testsRun, String(tests.length)) +
+        row(L.testsPassed, String(count("passed"))) +
+        row(L.testsFailed, String(count("failed"))) +
+        row(L.testsNotRun, String(count("refused"))) +
+        row(L.deviations, String(deviationsOf(result).length)) +
+        row(L.gateIssues, String(failing)) +
+        `</table></section>`);
+}
+function columnsOf(section, L) {
+    return section.columns.map((c) => (typeof c === "string" ? { key: c, heading: L[c] } : { key: c.key, heading: c.heading }));
+}
+function testsHtml(section, result, L) {
+    const tests = testsOf(result);
+    const columns = columnsOf(section, L);
+    const head = `<thead><tr>${columns.map((c) => `<th scope="col" data-column="${c.key}">${escapeHtml(c.heading)}</th>`).join("")}</tr></thead>`;
+    const bodies = tests.map(({ journey: j, role }, ti) => {
+        const verdictClass = j.status === "passed" ? "pass" : "fail";
+        const video = j.video
+            ? ` <a class="video" href="${escapeHtml(j.video)}" target="_blank" rel="noreferrer" data-testid="report-video-open">${escapeHtml(L.video)}: ${escapeHtml(j.video)}</a>`
+            : "";
+        const caption = `<tr class="test-head ${verdictClass}"><th colspan="${columns.length}" scope="rowgroup">` +
+            `<span class="verdict ${verdictClass}">${escapeHtml(resultWord(j.status, L))}</span> ` +
+            `<b>${cell(j.id)}</b> ${escapeHtml(j.name)} <span class="file">${escapeHtml(j.file)}${role === null ? "" : ` · ${escapeHtml(L.role)}: ${escapeHtml(role)}`}</span>${video}</th></tr>`;
+        const rows = j.steps.map((s, si) => {
+            const cells = columns.map(({ key }) => {
+                switch (key) {
+                    case "testId":
+                    case "requirements":
+                        // One cell for the whole test, spanning its steps.
+                        if (si > 0)
+                            return "";
+                        return `<td rowspan="${j.steps.length}" class="span">${key === "testId" ? cell(j.id) : j.requirements && j.requirements.length > 0 ? j.requirements.map(escapeHtml).join(", ") : MISSING}</td>`;
+                    case "step":
+                        return `<td class="step"><span class="n">${s.n}.</span> ${escapeHtml(s.caption)}</td>`;
+                    case "expected":
+                        return `<td>${cell(s.expected)}</td>`;
+                    case "actual":
+                        return `<td>${cell(actualOf(s, L))}</td>`;
+                    case "result":
+                        return `<td class="result r-${s.result}" data-result="${s.result}">${escapeHtml(resultWord(s.result, L))}</td>`;
+                    case "evidence":
+                        return `<td class="evidence">${frameCellHtml(s, L)}</td>`;
+                }
+            });
+            return `<tr class="${s.result}">${cells.join("")}</tr>`;
+        });
+        return `<tbody id="test-${ti + 1}" data-status="${j.status}">${caption}${rows.join("")}</tbody>`;
+    });
+    return (`<section class="tests" data-section="tests">${sectionHead(section, L.tests)}` +
+        (tests.length === 0 ? `<p class="none">${escapeHtml(L.noTests)}</p>` : `<table class="grid">${head}${bodies.join("")}</table>`) +
+        `</section>`);
+}
+/** Every step that failed or was refused, in the order of the tests. */
+export function deviationsOf(result, labels = {}) {
+    const L = { ...DEFAULT_LABELS, ...labels };
+    return testsOf(result).flatMap(({ journey: j }) => j.steps.flatMap((s) => s.result === "failed" || s.result === "refused"
+        ? [
+            {
+                test: j.name,
+                ...(j.id !== undefined ? { testId: j.id } : {}),
+                step: s.n,
+                caption: s.caption,
+                ...(s.expected !== undefined ? { expected: s.expected } : {}),
+                ...(actualOf(s, L) !== undefined ? { actual: actualOf(s, L) } : {}),
+                result: s.result,
+            },
+        ]
+        : []));
+}
+function deviationsHtml(section, result, L) {
+    const list = deviationsOf(result, L);
+    const body = list.length === 0
+        ? `<p class="none" data-testid="report-no-deviations">${escapeHtml(L.noDeviations)}</p>`
+        : `<table class="grid"><thead><tr><th scope="col">${escapeHtml(L.number)}</th><th scope="col">${escapeHtml(L.testId)}</th><th scope="col">${escapeHtml(L.test)}</th><th scope="col">${escapeHtml(L.step)}</th><th scope="col">${escapeHtml(L.expected)}</th><th scope="col">${escapeHtml(L.actual)}</th><th scope="col">${escapeHtml(L.result)}</th></tr></thead><tbody>` +
+            list
+                .map((d, i) => `<tr class="deviation" data-testid="report-deviation"><td>${i + 1}</td><td>${cell(d.testId)}</td><td>${escapeHtml(d.test)}</td><td><span class="n">${d.step}.</span> ${escapeHtml(d.caption)}</td><td>${cell(d.expected)}</td><td>${cell(d.actual)}</td><td>${escapeHtml(resultWord(d.result, L))}</td></tr>`)
+                .join("") +
+            `</tbody></table>`;
+    return `<section class="deviations" data-section="deviations">${sectionHead(section, L.deviations)}${body}</section>`;
+}
+function manifestHtml(section, result, meta, evidence, L) {
+    const facts = `<table class="facts">` +
+        `<tr><th scope="row">${escapeHtml(L.tool)}</th><td>${cell(meta.version)}</td></tr>` +
+        `<tr><th scope="row">${escapeHtml(L.target)}</th><td>${cell(result.url)}</td></tr>` +
+        `<tr><th scope="row">${escapeHtml(L.started)}</th><td>${cell(stamp(result.replay?.startedAt ?? result.generatedAt))}</td></tr>` +
+        `<tr><th scope="row">${escapeHtml(L.ended)}</th><td>${cell(stamp(result.generatedAt))}</td></tr>` +
+        `</table>`;
+    const rows = evidence
+        .map((e) => `<tr data-testid="report-manifest-entry"><td class="path">${escapeHtml(e.path)}</td><td>${e.bytes === null ? escapeHtml(L.notFound) : e.bytes}</td><td class="hash">${e.sha256 === null ? escapeHtml(L.notFound) : escapeHtml(e.sha256)}</td></tr>`)
+        .join("");
+    return (`<section class="manifest" data-section="manifest">${sectionHead(section, L.manifest)}${facts}` +
+        `<table class="grid"><thead><tr><th scope="col">${escapeHtml(L.file)}</th><th scope="col">${escapeHtml(L.bytes)}</th><th scope="col">${escapeHtml(L.sha256)}</th></tr></thead><tbody>${rows}</tbody></table></section>`);
+}
+function signoffHtml(section, L) {
+    const rows = section.roles
+        .map((r) => {
+        const role = typeof r === "string" ? r : r.role;
+        const meaning = typeof r === "string" ? undefined : r.meaning;
+        return `<tr class="signature"><td>${escapeHtml(role)}</td><td class="blank"></td><td class="blank"></td><td class="blank"></td><td>${meaning === undefined ? "" : escapeHtml(meaning)}</td></tr>`;
+    })
+        .join("");
+    return (`<section class="signoff" data-section="signoff">${sectionHead(section, L.signoff)}` +
+        `<table class="grid sign"><thead><tr><th scope="col">${escapeHtml(L.role)}</th><th scope="col">${escapeHtml(L.name)}</th><th scope="col">${escapeHtml(L.signature)}</th><th scope="col">${escapeHtml(L.signedDate)}</th><th scope="col">${escapeHtml(L.meaning)}</th></tr></thead><tbody>${rows}</tbody></table></section>`);
+}
+const STYLE = `
+:root { color-scheme: light; --line:#c9ced6; --text:#15181d; --muted:#5d6673; --pass:#047857; --pass-bg:#d1fae5; --fail:#b91c1c; --fail-bg:#fee2e2; --head:#eef0f3; }
+* { box-sizing:border-box; }
+body { margin:0; background:#fff; color:var(--text); font:14px/1.5 system-ui,-apple-system,"Segoe UI",sans-serif; }
+main { max-width:1100px; margin:0 auto; padding:24px 16px 64px; }
+header.title { border-bottom:2px solid var(--text); padding-bottom:12px; margin-bottom:8px; }
+header.title h1 { font-size:22px; margin:0 0 4px; }
+header.title .subtitle { margin:0 0 8px; color:var(--muted); }
+h2 { font-size:17px; margin:28px 0 8px; border-bottom:1px solid var(--line); padding-bottom:4px; }
+table { border-collapse:collapse; width:100%; margin:8px 0; }
+th, td { border:1px solid var(--line); padding:5px 8px; text-align:left; vertical-align:top; overflow-wrap:anywhere; }
+thead th, table.facts th { background:var(--head); }
+table.facts { width:auto; min-width:50%; }
+tr.test-head th { background:var(--head); font-weight:400; }
+.verdict { display:inline-block; padding:0 8px; border-radius:4px; font-weight:700; }
+.verdict.pass { color:var(--pass); background:var(--pass-bg); } .verdict.fail { color:var(--fail); background:var(--fail-bg); }
+.file { color:var(--muted); font-size:12px; }
+.n { color:var(--muted); font-weight:700; }
+td.step { font:12px/1.5 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace; }
+td.r-passed { color:var(--pass); font-weight:700; } td.r-failed, td.r-refused { color:var(--fail); font-weight:700; } td.r-not-run { color:var(--muted); }
+tr.failed td, tr.refused td { background:var(--fail-bg); }
+a.frame { display:block; color:var(--muted); font-size:11px; }
+a.frame img { display:block; max-width:220px; max-height:150px; object-fit:cover; object-position:top; border:1px solid var(--line); }
+td.hash, td.path { font:12px/1.5 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace; }
+table.sign td.blank { height:2.6em; min-width:8em; }
+.none { color:var(--muted); font-style:italic; }
+@media print { main { max-width:none; padding:0; } a { color:inherit; text-decoration:none; } tbody, tr { break-inside:avoid; } }
+`;
+/**
+ * The whole report: one HTML file with no scripts, no event handlers and no
+ * external assets. The frames and videos it links sit beside it, as they do
+ * for the replay page. Every word from the template and every value from the
+ * app is escaped.
+ */
+export function buildTemplateReport(result, template, evidence, meta) {
+    const L = { ...DEFAULT_LABELS, ...(template.labels ?? {}) };
+    const tokens = tokensOf(result, meta);
+    const title = fill(template.title, tokens);
+    const fields = [
+        ...(template.documentId !== undefined ? [{ label: L.documentId, value: fill(template.documentId, tokens) }] : []),
+        ...(template.fields ?? []).map((f) => ({ label: f.label, value: fill(f.value, tokens) })),
+    ];
+    const sections = template.sections.map((s) => {
+        switch (s.type) {
+            case "summary":
+                return summaryHtml(s, result, meta, L);
+            case "tests":
+                return testsHtml(s, result, L);
+            case "deviations":
+                return deviationsHtml(s, result, L);
+            case "manifest":
+                return manifestHtml(s, result, meta, evidence, L);
+            case "signoff":
+                return signoffHtml(s, L);
+            case "text":
+                return `<section class="text" data-section="text">${s.heading !== undefined ? `<h2>${escapeHtml(s.heading)}</h2>` : ""}${paragraphsHtml(s.paragraphs)}</section>`;
+        }
+    });
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="generator" content="${REPORT_GENERATOR}">
+<title>${escapeHtml(title)}</title>
+<style>${STYLE}</style>
+</head>
+<body>
+<main>
+<header class="title">
+<h1 data-testid="report-title">${escapeHtml(title)}</h1>
+${template.subtitle !== undefined ? `<p class="subtitle">${escapeHtml(fill(template.subtitle, tokens))}</p>\n` : ""}${fields.length > 0
+        ? `<table class="facts">${fields.map((f) => `<tr><th scope="row">${escapeHtml(f.label)}</th><td>${escapeHtml(f.value)}</td></tr>`).join("")}</table>\n`
+        : ""}</header>
+${sections.join("\n")}
+</main>
+</body>
+</html>
+`;
+}

package/dist/engine/check.js

@@ -503,6 +503,7 @@ export const CHECK_OPTION_NAMES = [
     "sarif-file-anchor",
     "record",
     "video",
+    "template",
 ];
 /** Options that may be given alone, meaning on: `--record`, as well as `--record on` and `--record=off`. */
 const SWITCH_OPTIONS = new Set(["record", "video"]);
@@ -685,6 +686,12 @@ export function parseCheckArgs(args, cwd) {
     if (videoRaw !== undefined && !SWITCH_ON.includes(videoRaw) && !SWITCH_OFF.includes(videoRaw)) {
         return { ok: false, error: "--video is on or off, or given alone for on" };
     }
+    const template = flags.get("template");
+    if (template !== undefined && template.trim() === "")
+        return { ok: false, error: "--template needs the path of a report template (JSON)" };
+    if (template !== undefined && recordRaw !== undefined && SWITCH_OFF.includes(recordRaw)) {
+        return { ok: false, error: "--template renders the report from a recorded check's frames, so it cannot be used with --record off" };
+    }
     const resolve = (p) => resolveArgPath(cwd, p);
     return {
         ok: true,
@@ -713,6 +720,7 @@ export function parseCheckArgs(args, cwd) {
             ...(anchor ? { sarifFileAnchor: anchor.value } : {}),
             ...(recordRaw !== undefined ? { record: SWITCH_ON.includes(recordRaw) } : {}),
             ...(videoRaw !== undefined && SWITCH_ON.includes(videoRaw) ? { video: true } : {}),
+            ...(template !== undefined ? { template: resolve(template) } : {}),
         },
     };
 }
@@ -1178,5 +1186,6 @@ export function toSummaryJson(result, toolVersion) {
         worthALook: result.worthALook,
         // Routes a check with no session was sent to sign-in from: a coverage gap. Absent when the check had a session.
         ...(result.needsSignIn ? { needsSignIn: result.needsSignIn } : {}),
+        ...(result.testReport ? { testReport: result.testReport } : {}),
     };
 }

package/dist/engine/flow.js

@@ -205,30 +205,41 @@ const target = z
         });
     }
 });
+/**
+ * What a step should bring about, in the words of the test it belongs to: the
+ * expected result a template-driven test report (`--template`) shows beside
+ * the step. Documentation only: it is never checked, so a step passes or
+ * fails on its action and its assertions alone.
+ */
+const expected = z.string().trim().min(1, "is the result the step should bring about, in words").max(500).optional();
 /** Most times a repeat step may run its steps. A longer loop is a page that should be reached another way. */
 export const MAX_REPEATS = 100;
 const SINGLE_STEP_SCHEMAS = [
-    z.object({ action: z.literal("navigate"), target: z.string().regex(/^\//, "must be a path on the app, starting with /") }).strict(),
-    z.object({ action: z.literal("click"), target }).strict(),
-    z.object({ action: z.literal("type"), target, value: z.string(), pressEnter: z.boolean().optional(), replace: z.boolean().optional() }).strict(),
-    z.object({ action: z.literal("select"), target, value: z.string() }).strict(),
-    z.object({ action: z.literal("press"), value: z.string().min(1, "names the key to press, e.g. Enter") }).strict(),
+    z.object({ action: z.literal("navigate"), expected, target: z.string().regex(/^\//, "must be a path on the app, starting with /") }).strict(),
+    z.object({ action: z.literal("click"), expected, target }).strict(),
+    z.object({ action: z.literal("type"), expected, target, value: z.string(), pressEnter: z.boolean().optional(), replace: z.boolean().optional() }).strict(),
+    z.object({ action: z.literal("select"), expected, target, value: z.string() }).strict(),
+    z.object({ action: z.literal("press"), expected, value: z.string().min(1, "names the key to press, e.g. Enter") }).strict(),
     // A small valid file generated for the input (its kind from `fixture`, else the input's accept attribute), as
     // scout_upload attaches one. `target` is the file input or the control that opens its chooser; absent, the page's only file input.
     z
         .object({
         action: z.literal("upload"),
+        expected,
         target: target.optional(),
         fixture: z.enum(FIXTURE_KINDS).optional(),
         name: z.string().min(1).max(120).optional(),
     })
         .strict(),
-    z.object({ action: z.literal("expect-text"), text: z.string().min(1, "is the text that must be visible") }).strict(),
-    z.object({ action: z.literal("expect-element"), target, state: z.enum(ELEMENT_STATES) }).strict(),
-    z.object({ action: z.literal("expect-url"), pattern: z.string().min(1).refine(isRegex, { message: "is not a valid regular expression" }) }).strict(),
+    z.object({ action: z.literal("expect-text"), expected, text: z.string().min(1, "is the text that must be visible") }).strict(),
+    z.object({ action: z.literal("expect-element"), expected, target, state: z.enum(ELEMENT_STATES) }).strict(),
+    z
+        .object({ action: z.literal("expect-url"), expected, pattern: z.string().min(1).refine(isRegex, { message: "is not a valid regular expression" }) })
+        .strict(),
     z
         .object({
         action: z.literal("expect-request"),
+        expected,
         request: z.string().regex(REQUEST_RE, 'must be a method and a path, e.g. "GET /api/things"'),
         status: z.union([z.number().int().min(100).max(599), z.string().regex(/^[1-5]xx$/, 'must be a status such as 200, or a class such as "2xx"')]),
     })
@@ -246,6 +257,7 @@ const isRepeatCondition = (s) => s.action === "expect-text" || s.action === "exp
 const repeatSchema = z
     .object({
     action: z.literal("repeat"),
+    expected,
     steps: z
         .array(singleStepSchema)
         .min(1, "needs at least one step to repeat")
@@ -262,6 +274,10 @@ const flowSchema = z
     .object({
     name: z.string().min(1).max(100).optional(),
     description: z.string().max(500).optional(),
+    /** The test's identifier in a template-driven test report (--template). Traceability only: the replay never reads it. */
+    id: z.string().trim().min(1, "is the test's identifier").max(100).optional(),
+    /** The requirement identifiers the flow covers, shown beside it in a template-driven test report. */
+    requirements: z.array(z.string().trim().min(1, "is a requirement identifier").max(100)).max(50, "holds at most 50 identifiers").optional(),
     /**
      * Who walks the flow: a role whose sign-in `scenescout login --role` saved in the project. Absent, the flow runs
      * in the check's own session. Flows run in file-name order, so one role's flow can pick up what another's left.
@@ -330,6 +346,10 @@ export function parseFlow(text, file) {
     const flow = { name: parsed.data.name ?? file.replace(/\.json$/i, ""), file, steps: parsed.data.steps };
     if (parsed.data.role !== undefined)
         flow.role = parsed.data.role;
+    if (parsed.data.id !== undefined)
+        flow.id = parsed.data.id;
+    if (parsed.data.requirements !== undefined)
+        flow.requirements = parsed.data.requirements;
     return { ok: true, flow };
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scenescout",
-  "version": "3.21.3",
+  "version": "3.22.0",
   "description": "SceneScout — exploratory UI testing for AI coding agents. An MCP server that gives any agent (Claude Code, Cursor, VS Code Copilot, Codex, Gemini CLI and others) a structured view of a running web app, always-on oracles, a network-level write policy, memory across runs and a gap-checked report.",
   "license": "MIT",
   "author": "brunoboto96",
@@ -73,7 +73,7 @@
     "mcp-check": "npm run build && npm run mcp-check:run",
     "mcp-check:run": "tsx scripts/mcp-check.ts",
     "test": "npm run build && npm run test:unit && npm run smoke:run && npm run mcp-check:run",
-    "test:unit": "npm run scan-test && npm run oracle-test && npm run policy-test && npm run fixture-test && npm run dispatch-test && npm run design-test && npm run check-test && npm run ci-test && npm run qa-test && npm run export-test && npm run contract-test && npm run pace-test && npm run limits-test && npm run request-test && npm run settle-test && npm run claims-test && npm run verify-test && npm run brief-test && npm run tickets-test && npm run lane-test && npm run calibration-test && npm run bench-test && npm run memory-test && npm run install-test && npm run profiles-test && npm run refresh-test && npm run scripted-login-test && npm run live-test && npm run demo-test && npm run holdout-test && npm run hygiene-test && npm run guide-test",
+    "test:unit": "npm run scan-test && npm run oracle-test && npm run policy-test && npm run fixture-test && npm run dispatch-test && npm run design-test && npm run check-test && npm run report-test && npm run ci-test && npm run qa-test && npm run export-test && npm run contract-test && npm run pace-test && npm run limits-test && npm run request-test && npm run settle-test && npm run claims-test && npm run verify-test && npm run brief-test && npm run tickets-test && npm run lane-test && npm run calibration-test && npm run bench-test && npm run memory-test && npm run install-test && npm run profiles-test && npm run refresh-test && npm run scripted-login-test && npm run live-test && npm run demo-test && npm run holdout-test && npm run hygiene-test && npm run guide-test",
     "scan-test": "tsx scripts/scan-test.ts",
     "oracle-test": "tsx --test scripts/oracle-test.ts",
     "policy-test": "tsx --test scripts/policy-test.ts",
@@ -81,6 +81,7 @@
     "dispatch-test": "tsx --test scripts/dispatch-test.ts",
     "design-test": "tsx --test scripts/design-test.ts",
     "check-test": "tsx --test scripts/check-test.ts",
+    "report-test": "tsx --test scripts/report-test.ts",
     "ci-test": "tsx --test scripts/ci-test.ts",
     "qa-test": "tsx --test scripts/qa-test.ts",
     "export-test": "tsx --test scripts/export-test.ts",