@majordigital/create-acorn 1.5.9 → 1.6.0

package/bin/create-acorn.mjs

@@ -89,6 +89,52 @@ function runCommand(cmd, args, options = {}) {
   });
 }
 
+async function setupPreDeploy() {
+  const pkgPath = join(process.cwd(), 'package.json');
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+  } catch {
+    console.log('Warning: Could not read package.json — skipping pre-deploy setup.');
+    return;
+  }
+
+  const alreadyInstalled =
+    pkg.scripts?.['lighthouse'] === 'node scripts/lighthouse-audit.mjs' &&
+    existsSync(join(process.cwd(), 'scripts', 'lighthouse-audit.mjs'));
+
+  if (alreadyInstalled) {
+    console.log('Pre-deploy tools already installed — skipping.');
+    console.log('');
+    return;
+  }
+
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const scriptsSrc = join(__dirname, '..', 'template', 'scripts');
+  const scriptsDest = join(process.cwd(), 'scripts');
+  mkdirSync(scriptsDest, { recursive: true });
+  cpSync(scriptsSrc, scriptsDest, { recursive: true, force: true });
+  console.log('Pre-deploy scripts copied to scripts/.');
+
+  console.log('Installing pre-deploy tools (Lighthouse, Playwright, linkinator)...');
+  await runCommand('npm', ['install', '--save-dev', '--legacy-peer-deps',
+    'lighthouse', 'chrome-launcher', 'playwright', 'linkinator'
+  ]);
+  console.log('');
+
+  try {
+    if (!pkg.scripts) pkg.scripts = {};
+    pkg.scripts['lighthouse'] = 'node scripts/lighthouse-audit.mjs';
+    pkg.scripts['check-links'] = 'node scripts/check-links.mjs';
+    pkg.scripts['cross-browser'] = 'node scripts/cross-browser-check.mjs';
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+    console.log('Added pre-deploy scripts to package.json.');
+  } catch {
+    console.log('Warning: Could not add pre-deploy scripts to package.json.');
+  }
+  console.log('');
+}
+
 async function setupNextApp() {
   console.log('Setting up Next.js 15 project...');
   console.log('');
@@ -150,6 +196,8 @@ async function setupNextApp() {
   console.log('');
   console.log('Biome, commitlint, and lefthook configured.');
   console.log('');
+
+  await setupPreDeploy();
 }
 
 async function setupPrismic(projectName) {
@@ -1050,6 +1098,15 @@ The primary contact for this project is [Davs Howard](mailto:davs@majordigital.c
 async function main() {
   printHeader();
 
+  // Standalone pre-deploy install — run in the current directory, no full setup needed
+  if (argv.includes('--add-pre-deploy')) {
+    console.log('Adding pre-deploy tools to the current project...');
+    console.log('');
+    await setupPreDeploy();
+    console.log('Done. Run /pre-deploy in Claude Code to start a pre-deployment validation.');
+    return;
+  }
+
   // Prompt for project name first
   const nameFromFlag = parseFlag('name');
   let projectDir = nameFromFlag;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@majordigital/create-acorn",
-  "version": "1.5.9",
+  "version": "1.6.0",
   "description": "Interactive starter CLI for Acorn with Storyblok/Prismic/DatoCMS, TypeScript, and Tailwind.",
   "bin": {
     "create-acorn": "bin/create-acorn.mjs",

package/template/.claude/commands/pre-deploy.md

@@ -0,0 +1,319 @@
+---
+description: "Run a comprehensive pre-deployment validation including code checks, browser tests, and Lighthouse audits"
+---
+
+# Pre-Deploy: Deployment Readiness Validation
+
+**User arguments:** $ARGUMENTS
+
+**Before starting, check for conflicts:** Run `ls ~/.claude/commands/pre-deploy.md 2>/dev/null` — if that file exists, **stop immediately** and tell the user: "A user-level `~/.claude/commands/pre-deploy.md` exists and will override this project command. Delete it with `rm ~/.claude/commands/pre-deploy.md` and re-run `/pre-deploy`." Do not proceed until the conflict is resolved.
+
+**Required scripts:** This command relies on scripts in `scripts/`. If they are missing, stop and tell the user to add them:
+- `scripts/check-links.mjs` — broken link crawler (uses `linkinator`)
+- `scripts/cross-browser-check.mjs` — cross-browser screenshots (uses `playwright`)
+- `scripts/lighthouse-audit.mjs` — Lighthouse audit runner (uses `lighthouse` + `chrome-launcher`)
+- `scripts/cleanup-screenshots.mjs` — removes artifacts older than 1 month
+
+These must also be wired up in `package.json`:
+```json
+"scripts": {
+  "lighthouse": "node scripts/lighthouse-audit.mjs",
+  "check-links": "node scripts/check-links.mjs",
+  "cross-browser": "node scripts/cross-browser-check.mjs"
+}
+```
+
+### How to run
+
+- `/pre-deploy` — Run all 7 phases from scratch (Phase 0 through Phase 6)
+- `/pre-deploy continue` — Read `progress.md` and resume from the first incomplete phase
+- `/pre-deploy continue phase 3` — Resume from Phase 3 specifically
+- `/pre-deploy phase 2` — Re-run only Phase 2, then continue through Phase 6
+- `/pre-deploy continue lighthouse` — Re-run only Phase 3 (Lighthouse), then continue through Phase 6
+
+**Tell the user at the start of every run:** "You can stop this process at any time. To resume, type `/pre-deploy continue` and it will pick up where it left off."
+
+### Determining the starting phase
+
+1. If `$ARGUMENTS` contains "continue" with no phase number: read `.claude/pre-deployment-result/progress.md`, find the first phase that is NOT marked "Done", and start from there.
+2. If `$ARGUMENTS` contains a phase number (e.g., "continue phase 3", "phase 5"): start from that phase.
+3. If `$ARGUMENTS` contains a phase name (e.g., "continue lighthouse", "continue browser", "continue links"): map to the phase number and start from there:
+   - "lighthouse" → Phase 3
+   - "browser" → Phase 2
+   - "links" → Phase 4
+   - "cross-browser" → Phase 5
+   - "report" → Phase 6
+4. If `$ARGUMENTS` is empty: run all phases starting from Phase 0.
+
+When resuming, do NOT re-run Phase 0 cleanup — only clean the specific phase directory being re-run (e.g., `rm -rf .claude/pre-deployment-result/lighthouse` before re-running Phase 3). This preserves completed work.
+
+### Progress tracking
+
+**At the start and end of every phase, print a progress summary to the user** showing the status of all 7 phases. Use this exact format:
+
+```
+Pre-Deploy Progress
+━━━━━━━━━━━━━━━━━━━━━
+Phase 0 — Cleanup            [Done]
+Phase 1 — Static Code Checks [In Progress]
+Phase 2 — Browser Checks     [Not Started]
+Phase 3 — Lighthouse Audit   [Not Started]
+Phase 4 — Broken Link Check  [Not Started]
+Phase 5 — Cross-Browser      [Not Started]
+Phase 6 — Final Report       [Not Started]
+━━━━━━━━━━━━━━━━━━━━━
+```
+
+Also write this status to `.claude/pre-deployment-result/progress.md` after each phase completes, so the user can check progress even in a new conversation.
+
+Execute **all 7 phases (Phase 0 through Phase 6)** below and present a final checklist report. Do not skip any phase (unless resuming from a specific phase).
+
+## Phase 0: Cleanup
+
+Before generating new artifacts, wipe the phase output directories to start fresh. **Do NOT delete previous reports** — those are kept for historical reference unless the user deletes them manually.
+
+```bash
+rm -rf .claude/pre-deployment-result/pre-deploy-screenshots
+rm -rf .claude/pre-deployment-result/lighthouse
+rm -rf .claude/pre-deployment-result/cross-browser
+rm -f .claude/pre-deployment-result/broken-links.md
+```
+
+This ensures no stale data from previous runs mixes with fresh results, while preserving previous reports (`pre-deploy-report-*.md`) for comparison.
+
+## Phase 1: Static Code Checks
+
+Run these checks against the codebase using grep/glob and report pass/fail for each:
+
+1. **No console.logs in production code** — Search `src/` for `console.log` statements. Ignore files in `node_modules/`, config files, and scripts. Report any found with file paths and line numbers.
+2. **No test/debug third-party tools** — Search for debug-only packages or scripts (e.g., `why-did-you-render`, `react-devtools`, debug toolbars, placeholder analytics IDs like `GTM-XXXX` or `UA-000000`). Check `package.json` for anything that should be in `devDependencies` but is in `dependencies`.
+3. **No test users or form data** — Search for hardcoded test data, dummy emails (`test@`, `example@`), placeholder usernames, or seed data that shouldn't ship.
+4. **Favicon exists** — Check that favicon files exist (e.g., `public/favicon.ico`, `app/favicon.ico`, or referenced in the layout/head).
+5. **robots.txt exists** — Check for `public/robots.txt` or a route that serves it.
+6. **Sitemap configured** — Check for sitemap generation (e.g., `sitemap.ts`, `sitemap.xml`, or a next-sitemap config).
+7. **Analytics code present** — Check for GTM, Google Analytics, or other analytics integration. Verify the ID is not a placeholder.
+8. **Metadata configured** — Check the root layout and page components for title, description, OpenGraph, and Twitter card metadata.
+9. **Legal pages exist** — Check routes/pages for privacy policy, terms of service, cookie policy, or similar legal content.
+10. **Webfonts configuration** — Check how fonts are loaded (next/font, Google Fonts link, self-hosted) and whether they're tied to a specific domain.
+
+## Phase 2: Browser Checks
+
+**Ask the user for the target URL first.** Do not start a dev server or assume localhost. Ask:
+
+> "What URL should I use for browser checks? Options:
+> - Production: `https://[your-production-url]`
+> - Staging: `https://[your-staging-url]`
+> - Local: `http://localhost:3000` (make sure the dev server is already running)
+> - Other: provide a URL"
+
+Wait for the user's response before proceeding. Use the provided URL for all browser checks in this phase.
+
+Before starting, ensure agent-browser is available:
+```bash
+agent-browser --version || (npm install -g agent-browser && agent-browser install --with-deps)
+```
+
+### Verify the correct project is running
+
+**Before taking any screenshots, verify the URL is serving the right project.** Check the page `<title>` tag and confirm it matches the expected site:
+
+```bash
+curl -s <target-url> | grep -o '<title>[^<]*</title>'
+```
+
+If the title does NOT match the expected project, **stop immediately** and tell the user: "The site at `<target-url>` appears to be serving a different project (found: [title]). Please check the URL and try again." Do not proceed with screenshots.
+
+**IMPORTANT:** After every `agent-browser open <url>`, always run `agent-browser wait --load networkidle` before taking a screenshot. This ensures CSS, fonts, and async content have fully loaded.
+
+### Infrastructure checks
+
+1. **Sitemap accessible** — Open `<target-url>/sitemap.xml`, wait for network idle, screenshot `pre-deploy-screenshots/01-sitemap.png`. Verify valid XML sitemap is returned.
+2. **robots.txt accessible** — Open `<target-url>/robots.txt`, wait for network idle, screenshot `pre-deploy-screenshots/02-robots.png`. Verify it returns valid content.
+3. **OG metadata present** — On the homepage, run:
+   ```
+   agent-browser eval "JSON.stringify({title: document.title, ogTitle: document.querySelector('meta[property=\"og:title\"]')?.content, ogDesc: document.querySelector('meta[property=\"og:description\"]')?.content, ogImage: document.querySelector('meta[property=\"og:image\"]')?.content, twitterCard: document.querySelector('meta[name=\"twitter:card\"]')?.content})"
+   ```
+   Verify all fields are populated and correct.
+4. **No console errors** — Run `agent-browser console` and `agent-browser errors` to check for JavaScript errors on key pages.
+
+### E2E page screenshots
+
+**Step 1 — Build the page list.** Fetch the sitemap at `<target-url>/sitemap.xml`. Extract all URLs. If there are more than 30 pages, sample intelligently: always include the homepage and 404, then keep all unique route templates while selecting one representative per large repeated group (e.g., one article per content type, one per top-level section).
+
+**Log the count before proceeding.** Example: "Pages: 18 pages to screenshot × 2 viewports = 36 screenshots."
+
+**Step 2 — Capture every page at both viewports.** For each page: open the URL, wait for network idle, take a full-page screenshot (`--full`), verify the page renders correctly (not blank, no error states).
+
+Before capturing, set the viewport:
+```bash
+# Desktop
+agent-browser set viewport 1440 900
+
+# Mobile
+agent-browser set viewport 390 844
+```
+
+Save desktop screenshots to `pre-deploy-screenshots/pages/desktop/` and mobile to `pre-deploy-screenshots/pages/mobile/`.
+
+5. **Homepage** — `<target-url>` → `desktop/01-homepage.png` + `mobile/01-homepage.png`
+6. **404 page** — `<target-url>/this-page-does-not-exist` → `desktop/02-404-page.png` + `mobile/02-404-page.png`. Verify a styled 404 page renders (not a blank white page or default Next.js error).
+7. **All remaining core pages** — Screenshot each unique page/template discovered from the sitemap, numbered sequentially. Desktop and mobile for each.
+8. **Legal pages accessible** — Visit each legal page found in Phase 1, verify they render with styled content.
+9. **Cookie popup appears (if configured)** — Check if a cookie consent banner appears on first load.
+
+**Step 3 — Verify completion.** Count files in `pre-deploy-screenshots/pages/desktop/` and `pre-deploy-screenshots/pages/mobile/`. Both counts must match the page count from Step 1. Capture any missing pages before proceeding.
+
+After all checks, close the browser:
+```bash
+agent-browser close
+```
+
+## Phase 3: Lighthouse Audit
+
+Run Lighthouse audits using `npm run lighthouse`. The script reads the sitemap, selects core pages (all unique templates, 1 sample per large repeated group), runs mobile and desktop audits concurrently, and saves results to `.claude/pre-deployment-result/lighthouse/`.
+
+**Use the same URL the user provided in Phase 2.** If Phase 2 was skipped (resuming), ask the user for the URL.
+
+```bash
+npm run lighthouse -- <target-url> .claude/pre-deployment-result/lighthouse
+```
+
+Results:
+- `lighthouse/summary.md` — scores for audited pages
+- `lighthouse/psi-links.md` — PageSpeed Insights links for all pages (for manual checking)
+
+### Monitoring Lighthouse progress
+
+Lighthouse is the slowest phase (~15 minutes with 3 concurrent Chrome instances). The script writes a `progress.json` file to the output directory after each batch of audits.
+
+**Important (Claude Code UI only):** If the user is on the desktop app or web app, remind them to keep the conversation open while Lighthouse runs. Navigating away or closing the conversation may prevent scheduled wake-ups from firing. This does not apply to the CLI.
+
+When checking on Lighthouse progress:
+
+1. **Read `progress.json`** — it shows `status` ("starting" / "running" / "complete"), `currentStrategy`, `completedInStrategy`, `totalInStrategy`, and `lastUpdatedAt`
+2. **Always tell the user concrete progress** (e.g., "Lighthouse: 8/22 mobile pages done, last updated 30s ago") rather than vague statements like "still running"
+3. **Never wait more than 5 minutes between checks** — use 270s intervals consistently
+4. **Detect stalls early:**
+   - If `progress.json` doesn't exist or is empty after 2 minutes, the script likely failed to start
+   - If `lastUpdatedAt` hasn't changed in over 5 minutes, the script is likely hung
+5. **When Lighthouse stalls or fails, offer alternatives:**
+   - **Option A: Give the user the PageSpeed Insights link for the page that hung** — so they can run that specific audit manually, then continue the report with scores already collected
+   - **Option B: Skip and include PSI links for all remaining pages** — produce the final report with scores for completed pages and direct PSI links for the rest
+   - **Option C: Retry** — kill the hung process, wipe the output directory, and re-run:
+     ```bash
+     kill <pid>
+     rm -rf .claude/pre-deployment-result/lighthouse
+     npm run lighthouse -- <same-base-url> .claude/pre-deployment-result/lighthouse
+     ```
+   - **Option D: Retry against localhost** — if the stall was a network/rate-limit issue, kill the hung process and re-run against the local dev server
+   - Always proceed to Phase 6 (final report) regardless — a report without complete Lighthouse scores is still valuable
+   - **Recovering partial results:** Read `.claude/pre-deployment-result/lighthouse/progress.json` — the `allResults` field contains scores collected before the hang. Use these in the final report alongside PSI links for remaining pages.
+
+After the script completes, read `lighthouse/summary.md` and include the scores table in the final report. Flag any category scoring below 90. Mention that `lighthouse/psi-links.md` has PSI links for all pages if the user wants to check any page manually.
+
+## Phase 4: Broken Link Check
+
+Run the broken link checker to crawl the site and find any broken internal links. **Use the same URL from Phase 2.**
+
+```bash
+npm run check-links -- <target-url> .claude/pre-deployment-result
+```
+
+Include the results in the final report. Any broken links should be flagged as High severity.
+
+## Phase 5: Cross-Browser Compatibility
+
+Run cross-browser screenshots across Chromium (Chrome/Edge), Firefox, and WebKit (Safari/Mobile Safari) at both desktop and mobile viewports. **Use the same URL from Phase 2.**
+
+```bash
+npm run cross-browser -- <target-url> .claude/pre-deployment-result/cross-browser
+```
+
+This tests key pages across all browser engines and captures console errors. Review the summary and flag any browser-specific rendering issues.
+
+Browser coverage:
+- **Chromium** → Chrome (Win/Mac), Edge (Win/Mac), Chrome (Android/iOS)
+- **Firefox** → Firefox (Win/Mac)
+- **WebKit** → Safari (Mac), Mobile Safari (iOS)
+
+## Phase 6: Final Report
+
+Save the report to `.claude/pre-deployment-result/pre-deploy-report-MM-DD-YY.md` using today's date. Use this exact format:
+
+```markdown
+# Pre-Deployment Validation Report
+
+**Date:** YYYY-MM-DD
+**Target:** <the URL(s) used for each phase>
+
+---
+
+## Issues Found
+
+Collect ALL issues from every phase into a single table, sorted by severity (High first, then Medium, then Low). Include the file path/location where relevant. This section goes first so it's the first thing the reader sees.
+
+| Severity | Issue | Location |
+|----------|-------|----------|
+| **High** | description of issue | file path or page |
+| **Medium** | description of issue | file path or page |
+| **Low** | description of issue | file path or page |
+
+---
+
+## Automated Checks (Pass/Fail)
+
+### Phase 1 — Static Code Checks
+- [x] or [ ] each check with details (file paths, what was found)
+
+### Phase 2 — Browser Checks
+- [x] or [ ] each check with details (page counts, screenshot counts, any errors found)
+
+### Phase 3 — Lighthouse Audit (N pages)
+
+**Mobile averages:** Performance **X** | Accessibility **X** | Best Practices **X** | SEO **X**
+**Desktop averages:** Performance **X** | Accessibility **X** | Best Practices **X** | SEO **X**
+
+Include the scores table from lighthouse/summary.md here.
+
+**Flags:**
+- List any categories below 90
+
+Full PSI links for all pages: see `lighthouse/psi-links.md`
+
+### Phase 4 — Broken Link Check
+- [x] or [ ] with broken link table (status, URL, occurrences)
+
+### Phase 5 — Cross-Browser Compatibility
+- [x] or [ ] with screenshot counts and any FAIL results
+
+---
+
+## Manual Verification Required
+- [ ] Confirm who will be the site's Webmaster
+- [ ] All page aliases/301 redirects are set up
+- [ ] Cookie popup is appropriate for target regions
+- [ ] Third-party APIs are configured for the production domain (not dev/staging keys)
+- [ ] Third-party webfonts are licensed/configured for the production domain
+- [ ] Required webhooks are set up and configured to trigger builds
+
+## Post-Deployment (within a few hours)
+- [ ] Approve site on Google Webmasters
+- [ ] Check site's visibility with Google
+- [ ] Check analytics are capturing correctly
+
+## Artifacts
+
+| Type | Location |
+|------|----------|
+| Infrastructure screenshots | `pre-deploy-screenshots/01-*.png` |
+| Desktop page screenshots | `pre-deploy-screenshots/pages/desktop/` |
+| Mobile page screenshots | `pre-deploy-screenshots/pages/mobile/` |
+| Lighthouse summary | `lighthouse/summary.md` |
+| Lighthouse PSI links | `lighthouse/psi-links.md` |
+| Broken links report | `broken-links.md` |
+| Cross-browser screenshots | `cross-browser/` |
+| Cross-browser summary | `cross-browser/summary.md` |
+| Progress tracker | `progress.md` |
+```
+
+Fill in actual results from each phase. For any failed checks, include details on what was found and where (file paths, line numbers, screenshot references). Group all issues into the "Issues Found" table at the top of the report.

package/template/scripts/check-links.mjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+/**
+ * Broken link checker using linkinator.
+ * Crawls the site and reports broken internal links.
+ *
+ * Usage:
+ *   node scripts/check-links.mjs <base-url> [output-dir]
+ *
+ * Example:
+ *   node scripts/check-links.mjs https://your-project.netlify.app
+ *   node scripts/check-links.mjs http://localhost:3000 .claude/pre-deployment-result
+ */
+
+import { LinkChecker } from "linkinator";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+
+const baseUrl = process.argv[2] || "http://localhost:3000";
+const outputDir = process.argv[3] || ".claude/pre-deployment-result";
+
+mkdirSync(outputDir, { recursive: true });
+
+const checker = new LinkChecker();
+
+checker.on("link", (result) => {
+    if (result.state === "BROKEN") {
+        console.log(
+            `  BROKEN [${result.status}] ${result.url} (from ${result.parent})`,
+        );
+    }
+});
+
+console.log(`Checking links on: ${baseUrl}`);
+console.log("This may take several minutes...\n");
+
+const result = await checker.check({
+    path: baseUrl,
+    recurse: true,
+    concurrency: 10,
+    timeout: 30000,
+    // Skip external links to avoid false positives from rate limiting
+    linksToSkip: [
+        "^(?!(" + baseUrl.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "))",
+    ],
+});
+
+const broken = result.links.filter((l) => l.state === "BROKEN");
+const ok = result.links.filter((l) => l.state === "OK");
+const skipped = result.links.filter((l) => l.state === "SKIPPED");
+
+console.log(`\n${"=".repeat(60)}`);
+console.log(`Link Check Results`);
+console.log(`${"=".repeat(60)}`);
+console.log(`Total links checked: ${result.links.length}`);
+console.log(`OK: ${ok.length}`);
+console.log(`Broken: ${broken.length}`);
+console.log(`Skipped: ${skipped.length}`);
+
+let md = `## Broken Link Check\n\n`;
+md += `Crawled: ${baseUrl}\n\n`;
+md += `| Metric | Count |\n|--------|-------|\n`;
+md += `| Total links | ${result.links.length} |\n`;
+md += `| OK | ${ok.length} |\n`;
+md += `| Broken | ${broken.length} |\n`;
+md += `| Skipped | ${skipped.length} |\n\n`;
+
+if (broken.length > 0) {
+    const grouped = new Map();
+    for (const link of broken) {
+        const key = link.url;
+        if (!grouped.has(key)) {
+            grouped.set(key, { status: link.status, url: link.url, foundOn: new Set() });
+        }
+        grouped.get(key).foundOn.add(link.parent);
+    }
+
+    md += `### Broken Links (${grouped.size} unique)\n\n`;
+    md += `| Status | URL | Found on (${broken.length} total occurrences) |\n|--------|-----|----------|\n`;
+    for (const [, entry] of grouped) {
+        const pages = [...entry.foundOn];
+        const foundOnText =
+            pages.length <= 3
+                ? pages.join(", ")
+                : `${pages.slice(0, 3).join(", ")} + ${pages.length - 3} more pages`;
+        md += `| ${entry.status || "N/A"} | ${entry.url} | ${foundOnText} |\n`;
+    }
+} else {
+    md += `No broken links found.\n`;
+}
+
+writeFileSync(join(outputDir, "broken-links.md"), md);
+console.log(`\nReport saved to ${join(outputDir, "broken-links.md")}`);
+
+if (broken.length > 0) {
+    process.exit(1);
+}

package/template/scripts/cleanup-screenshots.mjs

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+
+/**
+ * Deletes pre-deployment artifacts older than 1 month.
+ * Covers screenshots, cross-browser results, and lighthouse reports.
+ *
+ * Usage:
+ *   node scripts/cleanup-screenshots.mjs [--dry-run] [--list]
+ *
+ * Options:
+ *   --dry-run   Preview what will be deleted without removing anything
+ *   --list      Show all files with their age (nothing is deleted)
+ */
+
+import { readdirSync, statSync, rmSync } from "node:fs";
+import { join } from "node:path";
+
+const dirs = [
+    ".claude/pre-deployment-result/pre-deploy-screenshots",
+    ".claude/pre-deployment-result/cross-browser",
+    ".claude/pre-deployment-result/lighthouse",
+];
+
+const dryRun = process.argv.includes("--dry-run");
+const listOnly = process.argv.includes("--list");
+const oneMonthMs = 30 * 24 * 60 * 60 * 1000;
+const oneMonthAgo = Date.now() - oneMonthMs;
+
+function formatAge(mtimeMs) {
+    const ageMs = Date.now() - mtimeMs;
+    const days = Math.floor(ageMs / (24 * 60 * 60 * 1000));
+    if (days === 0) return "today";
+    if (days === 1) return "1 day ago";
+    if (days < 30) return `${days} days ago`;
+    const months = Math.floor(days / 30);
+    return `${months} month${months > 1 ? "s" : ""} ago (${days} days)`;
+}
+
+function cleanDir(dir) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    } catch {
+        return { removed: 0, listed: 0 };
+    }
+
+    let removed = 0;
+    let listed = 0;
+
+    for (const entry of entries) {
+        const fullPath = join(dir, entry);
+        const stat = statSync(fullPath);
+
+        if (stat.isDirectory()) {
+            const result = cleanDir(fullPath);
+            removed += result.removed;
+            listed += result.listed;
+            try {
+                const remaining = readdirSync(fullPath);
+                if (remaining.length === 0 && !listOnly) {
+                    if (dryRun) {
+                        console.log(`[dry-run] rmdir: ${fullPath}`);
+                    } else {
+                        rmSync(fullPath);
+                        console.log(`Removed empty dir: ${fullPath}`);
+                    }
+                }
+            } catch {
+                // ignore
+            }
+            continue;
+        }
+
+        const age = formatAge(stat.mtimeMs);
+        listed++;
+
+        if (listOnly) {
+            const old = stat.mtimeMs < oneMonthAgo ? " [OLD]" : "";
+            console.log(`  ${age}${old}  ${fullPath}`);
+            continue;
+        }
+
+        if (stat.mtimeMs < oneMonthAgo) {
+            if (dryRun) {
+                console.log(`[dry-run] delete (${age}): ${fullPath}`);
+            } else {
+                rmSync(fullPath);
+                console.log(`Deleted (${age}): ${fullPath}`);
+            }
+            removed++;
+        }
+    }
+
+    return { removed, listed };
+}
+
+let totalRemoved = 0;
+let totalListed = 0;
+
+for (const dir of dirs) {
+    console.log(`\nScanning: ${dir}`);
+    const { removed, listed } = cleanDir(dir);
+    totalRemoved += removed;
+    totalListed += listed;
+}
+
+if (listOnly) {
+    console.log(`\nTotal files: ${totalListed}`);
+} else {
+    console.log(
+        `\n${dryRun ? "[dry-run] Would delete" : "Deleted"} ${totalRemoved} file(s) older than 1 month.`,
+    );
+}

package/template/scripts/cross-browser-check.mjs

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+
+/**
+ * Cross-browser screenshot and compatibility check.
+ * Takes screenshots across Chromium (Chrome/Edge), Firefox, and WebKit (Safari).
+ *
+ * Usage:
+ *   node scripts/cross-browser-check.mjs <base-url> [output-dir]
+ *
+ * Example:
+ *   node scripts/cross-browser-check.mjs https://your-project.netlify.app
+ *   node scripts/cross-browser-check.mjs http://localhost:3000 .claude/pre-deployment-result/cross-browser
+ */
+
+import { chromium, firefox, webkit } from "playwright";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+
+const baseUrl = process.argv[2] || "http://localhost:3000";
+const outputDir = process.argv[3] || ".claude/pre-deployment-result/cross-browser";
+
+// Browsers to test — covers the full support matrix:
+// Chromium  → Chrome (Win/Mac), Edge (Win/Mac), Chrome (Android/iOS)
+// Firefox   → Firefox (Win/Mac)
+// WebKit    → Safari (Mac), Mobile Safari (iOS)
+const browsers = [
+    { name: "chromium", engine: chromium },
+    { name: "firefox", engine: firefox },
+    { name: "webkit", engine: webkit },
+];
+
+const viewports = [
+    { name: "desktop", width: 1440, height: 900, isMobile: false },
+    { name: "mobile", width: 390, height: 844, isMobile: true },
+];
+
+/**
+ * Fetches all URLs from sitemap.xml and returns a representative sample.
+ * Always includes homepage and 404. For large sitemaps, samples 1 page
+ * per top-level section to keep the test suite manageable.
+ */
+async function discoverPages(base) {
+    const sitemapUrl = `${base}/sitemap.xml`;
+    console.log(`Fetching sitemap: ${sitemapUrl}`);
+
+    try {
+        const res = await fetch(sitemapUrl);
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        const xml = await res.text();
+
+        const urls = [...xml.matchAll(/<loc>([^<]+)<\/loc>/g)].map((m) => m[1]);
+        if (urls.length === 0) throw new Error("No URLs found in sitemap");
+
+        const allPages = urls.map((raw) => {
+            const path = new URL(raw).pathname;
+            const name =
+                path === "/"
+                    ? "homepage"
+                    : path.replace(/^\/|\/$/g, "").replaceAll("/", "--");
+            return { name, path };
+        });
+
+        // For large sitemaps (>30 pages), sample: keep all shallow pages
+        // (depth 1-2) plus 1 page per top-level section for deeper routes.
+        let pages;
+        if (allPages.length <= 30) {
+            pages = allPages;
+        } else {
+            const seenSections = new Set();
+            pages = allPages.filter((p) => {
+                const segments = p.path.replace(/^\/|\/$/g, "").split("/");
+                if (segments.length <= 2) return true; // always include shallow pages
+                const section = segments[0];
+                if (seenSections.has(section)) return false;
+                seenSections.add(section);
+                return true;
+            });
+            console.log(
+                `Large sitemap: sampled ${pages.length} of ${allPages.length} pages (1 per section for deep routes)\n`,
+            );
+        }
+
+        // Always include 404
+        pages.push({ name: "404", path: "/this-page-does-not-exist" });
+
+        console.log(`Testing ${pages.length} pages\n`);
+        return pages;
+    } catch (err) {
+        console.warn(`Could not fetch sitemap (${err.message}), using fallback pages`);
+        return [
+            { name: "homepage", path: "/" },
+            { name: "404", path: "/this-page-does-not-exist" },
+        ];
+    }
+}
+
+const pages = await discoverPages(baseUrl);
+const results = [];
+
+for (const { name: browserName, engine } of browsers) {
+    console.log(`\n${"=".repeat(60)}`);
+    console.log(`Testing: ${browserName}`);
+    console.log(`${"=".repeat(60)}`);
+
+    const browser = await engine.launch({ headless: true });
+
+    for (const viewport of viewports) {
+        const dirPath = join(outputDir, `${browserName}-${viewport.name}`);
+        mkdirSync(dirPath, { recursive: true });
+
+        const contextOptions = {
+            viewport: { width: viewport.width, height: viewport.height },
+        };
+        // Firefox doesn't support isMobile
+        if (viewport.isMobile && browserName !== "firefox") {
+            contextOptions.isMobile = true;
+        }
+        const context = await browser.newContext(contextOptions);
+        const page = await context.newPage();
+
+        const consoleErrors = [];
+        page.on("console", (msg) => {
+            if (msg.type() === "error") consoleErrors.push(msg.text());
+        });
+        page.on("pageerror", (err) => {
+            consoleErrors.push(err.message);
+        });
+
+        for (const { name: pageName, path } of pages) {
+            const url = `${baseUrl}${path}`;
+            console.log(`  [${browserName}/${viewport.name}] ${pageName}: ${url}`);
+
+            try {
+                const response = await page.goto(url, {
+                    waitUntil: "networkidle",
+                    timeout: 30000,
+                });
+
+                const status = response?.status() || 0;
+
+                const label = `${browserName} — ${viewport.name} (${viewport.width}x${viewport.height})`;
+                await page.evaluate((text) => {
+                    const banner = document.createElement("div");
+                    banner.textContent = text;
+                    banner.style.cssText =
+                        "position:fixed;top:0;left:0;right:0;z-index:999999;" +
+                        "background:#1a1a2e;color:#e0e0e0;font:bold 14px/1 monospace;" +
+                        "padding:8px 16px;text-align:center;letter-spacing:0.5px;";
+                    document.body.prepend(banner);
+                }, label);
+
+                await page.screenshot({
+                    path: join(dirPath, `${pageName}.png`),
+                    fullPage: true,
+                });
+
+                const errors = [...consoleErrors];
+                consoleErrors.length = 0;
+
+                results.push({
+                    browser: browserName,
+                    viewport: viewport.name,
+                    page: pageName,
+                    url,
+                    status,
+                    errors,
+                    ok: true,
+                });
+
+                if (errors.length > 0) {
+                    console.log(`    Console errors: ${errors.length}`);
+                }
+            } catch (err) {
+                results.push({
+                    browser: browserName,
+                    viewport: viewport.name,
+                    page: pageName,
+                    url,
+                    status: 0,
+                    errors: [err.message],
+                    ok: false,
+                });
+                console.log(`    FAILED: ${err.message}`);
+            }
+        }
+
+        await context.close();
+    }
+
+    await browser.close();
+}
+
+let md = `## Cross-Browser Compatibility Check\n\n`;
+md += `Tested ${pages.length} pages across ${browsers.length} browsers (desktop + mobile).\n\n`;
+
+md += `### Browser Coverage\n\n`;
+md += `| Browser Engine | Covers |\n|----------------|--------|\n`;
+md += `| Chromium | Chrome (Win/Mac), Edge (Win/Mac), Chrome (Android/iOS) |\n`;
+md += `| Firefox | Firefox (Win/Mac) |\n`;
+md += `| WebKit | Safari (Mac), Mobile Safari (iOS) |\n\n`;
+
+md += `### Results\n\n`;
+md += `| Browser | Viewport | Page | Status | Console Errors | Screenshot |\n`;
+md += `|---------|----------|------|--------|----------------|------------|\n`;
+
+for (const r of results) {
+    const statusIcon = r.ok ? (r.status === 200 || r.status === 404 ? "OK" : `${r.status}`) : "FAIL";
+    const errorCount = r.errors.length > 0 ? `${r.errors.length} error(s)` : "None";
+    const screenshot = `${r.browser}-${r.viewport}/${r.page}.png`;
+    md += `| ${r.browser} | ${r.viewport} | ${r.page} | ${statusIcon} | ${errorCount} | ${screenshot} |\n`;
+}
+
+const withErrors = results.filter((r) => r.errors.length > 0);
+if (withErrors.length > 0) {
+    md += `\n### Console Errors Detail\n\n`;
+    for (const r of withErrors) {
+        md += `**${r.browser}/${r.viewport} — ${r.page}**\n`;
+        for (const err of r.errors) {
+            md += `- \`${err.slice(0, 200)}\`\n`;
+        }
+        md += `\n`;
+    }
+}
+
+const failedInSome = pages
+    .map((p) => {
+        const pageResults = results.filter((r) => r.page === p.name);
+        const failedBrowsers = pageResults.filter((r) => !r.ok);
+        return { page: p.name, failedBrowsers };
+    })
+    .filter((p) => p.failedBrowsers.length > 0 && p.failedBrowsers.length < results.filter((r) => r.page === p.page).length);
+
+if (failedInSome.length > 0) {
+    md += `\n### Browser-Specific Issues\n\n`;
+    for (const p of failedInSome) {
+        const browserList = p.failedBrowsers.map((r) => `${r.browser}/${r.viewport}`).join(", ");
+        md += `- **${p.page}** fails in: ${browserList}\n`;
+    }
+}
+
+md += `\nScreenshots saved to \`${outputDir}/\`\n`;
+
+writeFileSync(join(outputDir, "summary.md"), md);
+console.log(`\nSummary saved to ${join(outputDir, "summary.md")}`);

package/template/scripts/lighthouse-audit.mjs

@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+
+/**
+ * Lighthouse audit script for pre-deployment validation.
+ * Runs both mobile and desktop audits on pages discovered from the sitemap.
+ *
+ * Usage:
+ *   node scripts/lighthouse-audit.mjs <base-url> [output-dir] [--all] [--concurrency=N]
+ *
+ * Options:
+ *   --all           Audit ALL pages from sitemap instead of core sample
+ *   --concurrency=N Number of concurrent Chrome instances (default: 3)
+ *
+ * By default (core mode), audits a representative sample:
+ *   - All pages at depth 1-2 (e.g. /, /about, /blog)
+ *   - 1 page per top-level section for deeper routes (e.g. one /blog/* post)
+ *
+ * Examples:
+ *   node scripts/lighthouse-audit.mjs https://your-project.netlify.app
+ *   node scripts/lighthouse-audit.mjs http://localhost:3000 .claude/pre-deployment-result/lighthouse
+ *   node scripts/lighthouse-audit.mjs https://your-project.netlify.app --all
+ */
+
+import { launch } from "chrome-launcher";
+import lighthouse from "lighthouse";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { fork } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+// Worker mode: run a single audit in a child process and report back
+if (process.argv.includes("--worker")) {
+    process.on("message", async (msg) => {
+        try {
+            const chrome = await launch({ chromeFlags: ["--headless", "--no-sandbox"] });
+            const result = await lighthouse(msg.url, {
+                port: chrome.port,
+                output: "json",
+                onlyCategories: msg.categories,
+                formFactor: msg.formFactor,
+                screenEmulation: msg.screenEmulation,
+            });
+            await chrome.kill();
+
+            const scores = {};
+            for (const cat of msg.categories) {
+                scores[cat] = Math.round((result.lhr.categories[cat]?.score || 0) * 100);
+            }
+            process.send({ scores });
+        } catch (err) {
+            process.send({ error: err.message });
+        }
+        process.exit(0);
+    });
+} else {
+
+const args = process.argv.slice(2);
+const flags = args.filter((a) => a.startsWith("--"));
+const positional = args.filter((a) => !a.startsWith("--"));
+
+const baseUrl = positional[0] || "http://localhost:3000";
+const outputDir = positional[1] || ".claude/pre-deployment-result/lighthouse";
+const auditAll = flags.includes("--all");
+const coreOnly = !auditAll;
+const concurrency = Number.parseInt(
+    flags.find((f) => f.startsWith("--concurrency="))?.split("=")[1] || "3",
+    10,
+);
+
+const categories = ["performance", "accessibility", "best-practices", "seo"];
+
+const strategies = [
+    {
+        name: "Mobile",
+        formFactor: "mobile",
+        screenEmulation: { mobile: true, width: 412, height: 823, deviceScaleFactor: 1.75 },
+    },
+    {
+        name: "Desktop",
+        formFactor: "desktop",
+        screenEmulation: { mobile: false, width: 1350, height: 940, deviceScaleFactor: 1 },
+    },
+];
+
+/**
+ * Groups a path by its top-level section for sampling.
+ * Depth 0-2: treated as unique pages (always audited in core mode).
+ * Depth 3+: grouped by top-level segment (1 audited per group in core mode).
+ */
+function classifyRoute(path) {
+    const segments = path.replace(/^\/|\/$/g, "").split("/").filter(Boolean);
+    if (segments.length === 0) return { depth: 0, group: "homepage" };
+    if (segments.length <= 2) return { depth: segments.length, group: path };
+    return { depth: segments.length, group: segments[0] };
+}
+
+/**
+ * Fetches all URLs from sitemap.xml, rebases them to the target URL,
+ * and returns both the core sample and the full page list.
+ */
+async function discoverPages(base) {
+    const sitemapUrl = `${base}/sitemap.xml`;
+    console.log(`Fetching sitemap: ${sitemapUrl}`);
+
+    try {
+        const res = await fetch(sitemapUrl);
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        const xml = await res.text();
+
+        const rawUrls = [...xml.matchAll(/<loc>([^<]+)<\/loc>/g)].map((m) => m[1]);
+        if (rawUrls.length === 0) throw new Error("No URLs found in sitemap");
+
+        console.log(`Found ${rawUrls.length} pages in sitemap`);
+
+        const allPages = rawUrls.map((raw) => {
+            const path = new URL(raw).pathname;
+            const url = `${base}${path}`;
+            const name =
+                path === "/"
+                    ? "homepage"
+                    : path.replace(/^\/|\/$/g, "").replaceAll("/", "--");
+            return { name, url, path };
+        });
+
+        if (auditAll) {
+            console.log(`Auditing all ${allPages.length} pages\n`);
+            return { audited: allPages, all: allPages };
+        }
+
+        // Core mode: all shallow pages + 1 per top-level section for deeper routes
+        const seenGroups = new Set();
+        const corePages = allPages.filter((p) => {
+            const { depth, group } = classifyRoute(p.path);
+            if (depth <= 2) return true;
+            if (seenGroups.has(group)) return false;
+            seenGroups.add(group);
+            return true;
+        });
+
+        console.log(`\nCore mode: ${corePages.length} pages to audit (of ${allPages.length} total)`);
+        for (const p of corePages) console.log(`  ${p.path}`);
+        console.log(`\nFull PSI links for all ${allPages.length} pages will be in the report.\n`);
+
+        return { audited: corePages, all: allPages };
+    } catch (err) {
+        console.warn(`Could not fetch sitemap (${err.message}), falling back to homepage only`);
+        const fallback = [{ name: "homepage", url: base, path: "/" }];
+        return { audited: fallback, all: fallback };
+    }
+}
+
+function psiLink(url, strategy) {
+    return `https://pagespeed.web.dev/analysis?url=${encodeURIComponent(url)}&form_factor=${strategy.toLowerCase()}`;
+}
+
+function buildTable(results) {
+    const header = "| Page | Performance | Accessibility | Best Practices | SEO | Report |";
+    const divider = "|------|------------|---------------|----------------|-----|--------|";
+    const rows = results
+        .map((r) => `| ${r.name} | ${r.scores.performance} | ${r.scores.accessibility} | ${r.scores["best-practices"]} | ${r.scores.seo} | [View](${r.psiLink}) |`)
+        .join("\n");
+
+    const avg = {};
+    for (const cat of categories) {
+        avg[cat] = Math.round(results.reduce((sum, r) => sum + r.scores[cat], 0) / results.length);
+    }
+    const avgRow = `| **Average** | **${avg.performance}** | **${avg.accessibility}** | **${avg["best-practices"]}** | **${avg.seo}** | |`;
+
+    return `${header}\n${divider}\n${rows}\n${avgRow}`;
+}
+
+function buildFlaggedSection(results) {
+    const flagged = results.filter((r) => categories.some((cat) => r.scores[cat] < 90));
+    if (flagged.length === 0) return "";
+
+    const items = flagged
+        .map((r) => {
+            const low = categories
+                .filter((cat) => r.scores[cat] < 90)
+                .map((cat) => `${cat}: ${r.scores[cat]}`)
+                .join(", ");
+            return `- **${r.name}** — ${low}`;
+        })
+        .join("\n");
+
+    return `\n### Pages below 90 in any category\n\n${items}\n`;
+}
+
+mkdirSync(outputDir, { recursive: true });
+
+const progressFile = join(outputDir, "progress.json");
+
+function writeProgress(data, allResults = null, pages = null) {
+    const combined = { ...data };
+    if (allResults) combined.allResults = allResults;
+    if (pages) combined.pages = pages;
+    writeFileSync(progressFile, JSON.stringify(combined, null, 2));
+}
+
+const { audited: pages, all: allPages } = await discoverPages(baseUrl);
+const startedAt = new Date().toISOString();
+
+writeProgress({
+    status: "starting",
+    totalPages: pages.length,
+    strategies: strategies.map((s) => s.name),
+    startedAt,
+});
+
+const effectiveConcurrency = Math.min(concurrency, pages.length) || 1;
+console.log(`Running audits with concurrency ${effectiveConcurrency} (separate processes)\n`);
+
+const thisFile = fileURLToPath(import.meta.url);
+
+function auditPageInWorker(page, strategy) {
+    return new Promise((resolve, reject) => {
+        const child = fork(thisFile, ["--worker"], { silent: true });
+
+        child.send({
+            url: page.url,
+            categories,
+            formFactor: strategy.formFactor,
+            screenEmulation: strategy.screenEmulation,
+        });
+
+        child.on("message", (msg) => {
+            if (msg.error) reject(new Error(msg.error));
+            else resolve({
+                name: page.name,
+                url: page.url,
+                scores: msg.scores,
+                psiLink: psiLink(page.url, strategy.name),
+            });
+        });
+
+        child.on("error", reject);
+        child.on("exit", (code) => {
+            if (code !== 0) reject(new Error(`Worker exited with code ${code}`));
+        });
+    });
+}
+
+async function auditBatch(pages, strategy) {
+    const results = [];
+    let completed = 0;
+
+    for (let i = 0; i < pages.length; i += effectiveConcurrency) {
+        const batch = pages.slice(i, i + effectiveConcurrency);
+        const batchLabel = batch.map((p) => p.name).join(", ");
+        console.log(`[${strategy.name}] Batch [${completed + 1}-${completed + batch.length}/${pages.length}]: ${batchLabel}`);
+
+        const batchResults = await Promise.all(batch.map((page) => auditPageInWorker(page, strategy)));
+
+        for (const r of batchResults) {
+            results.push(r);
+            completed++;
+            console.log(`  ${r.name}: Performance: ${r.scores.performance} | Accessibility: ${r.scores.accessibility} | Best Practices: ${r.scores["best-practices"]} | SEO: ${r.scores.seo}`);
+        }
+
+        writeProgress({
+            status: "running",
+            currentStrategy: strategy.name,
+            completedInStrategy: completed,
+            totalInStrategy: pages.length,
+            totalPages: pages.length,
+            strategies: strategies.map((s) => s.name),
+            startedAt,
+            lastUpdatedAt: new Date().toISOString(),
+            lastPage: batchResults[batchResults.length - 1].name,
+            lastPageUrl: batchResults[batchResults.length - 1].url,
+            lastScores: batchResults[batchResults.length - 1].scores,
+        }, allResults, pages);
+    }
+
+    return results;
+}
+
+const allResults = {};
+
+for (const strategy of strategies) {
+    console.log(`\n${"=".repeat(60)}`);
+    console.log(`Running ${strategy.name} audits`);
+    console.log(`${"=".repeat(60)}`);
+    allResults[strategy.name] = await auditBatch(pages, strategy);
+}
+
+const sections = strategies.map((strategy) => {
+    const results = allResults[strategy.name];
+    const table = buildTable(results);
+    const flagged = buildFlaggedSection(results);
+    return `## Lighthouse Audit — ${strategy.name}\n\nAudited ${results.length} pages from sitemap.\n\n${table}\n${flagged}`;
+});
+
+const auditedNames = new Set(pages.map((p) => p.name));
+const psiRows = allPages.map((p) => {
+    const audited = auditedNames.has(p.name) ? "Yes" : "";
+    return `| ${p.name} | ${audited} | [Mobile](${psiLink(p.url, "Mobile")}) | [Desktop](${psiLink(p.url, "Desktop")}) |`;
+});
+const psiLinksContent = `# PageSpeed Insights Links — All Pages
+
+${allPages.length} pages total. Audited pages are marked — click any PSI link to check a specific page manually.
+
+| Page | Audited | Mobile PSI | Desktop PSI |
+|------|---------|-----------|-------------|
+${psiRows.join("\n")}
+`;
+
+writeFileSync(join(outputDir, "psi-links.md"), psiLinksContent);
+
+const summary = sections.join("\n---\n\n") + `\n\n---\n\nFull PSI links for all ${allPages.length} pages: see \`psi-links.md\`\n`;
+writeFileSync(join(outputDir, "summary.md"), summary);
+
+writeProgress({ status: "complete", totalPages: pages.length, completedAt: new Date().toISOString() });
+
+console.log(`\nSummary saved to ${join(outputDir, "summary.md")}`);
+console.log(`PSI links saved to ${join(outputDir, "psi-links.md")}`);
+console.log("\n" + summary);
+
+} // end non-worker mode