@dfosco/storyboard-core 4.2.0-beta.3 → 4.2.0

package/src/lib/components/ui/toggle-group/toggle-group-item.jsx

@@ -0,0 +1,29 @@
+import { forwardRef } from "react";
+import * as ToggleGroupPrimitive from "@radix-ui/react-toggle-group";
+import { useToggleGroupCtx } from "./toggle-group.jsx";
+import { cn } from "../../../utils/index.js";
+import { toggleVariants } from "../../../components/ui/toggle/index.js";
+
+const ToggleGroupItem = forwardRef(function ToggleGroupItem({ className, variant, size, ...props }, ref) {
+const ctx = useToggleGroupCtx();
+
+return (
+<ToggleGroupPrimitive.Item
+ref={ref}
+data-slot="toggle-group-item"
+data-variant={ctx.variant || variant}
+data-size={ctx.size || size}
+data-spacing={ctx.spacing}
+className={cn(
+"group-data-[spacing=0]/toggle-group:rounded-none group-data-[spacing=0]/toggle-group:px-2 group-data-horizontal/toggle-group:data-[spacing=0]:first:rounded-l-lg group-data-vertical/toggle-group:data-[spacing=0]:first:rounded-t-lg group-data-horizontal/toggle-group:data-[spacing=0]:last:rounded-r-lg group-data-vertical/toggle-group:data-[spacing=0]:last:rounded-b-lg shrink-0 focus:z-10 focus-visible:z-10 group-data-horizontal/toggle-group:data-[spacing=0]:data-[variant=outline]:border-l-0 group-data-vertical/toggle-group:data-[spacing=0]:data-[variant=outline]:border-t-0 group-data-horizontal/toggle-group:data-[spacing=0]:data-[variant=outline]:first:border-l group-data-vertical/toggle-group:data-[spacing=0]:data-[variant=outline]:first:border-t",
+toggleVariants({
+variant: ctx.variant || variant,
+size: ctx.size || size,
+}),
+className
+)}
+{...props}
+/>
+);
+});
+export default ToggleGroupItem;

package/src/lib/components/ui/toggle-group/toggle-group.jsx

@@ -0,0 +1,43 @@
+import { forwardRef, createContext, useContext, useMemo } from "react";
+import * as ToggleGroupPrimitive from "@radix-ui/react-toggle-group";
+import { cn } from "../../../utils/index.js";
+
+export const ToggleGroupContext = createContext({
+variant: "default",
+size: "default",
+spacing: 0,
+orientation: "horizontal",
+});
+
+export function useToggleGroupCtx() {
+return useContext(ToggleGroupContext);
+}
+
+const ToggleGroup = forwardRef(function ToggleGroup(
+{ className, variant = "default", size = "default", spacing = 0, orientation = "horizontal", children, ...props },
+ref
+) {
+const ctx = useMemo(() => ({ variant, size, spacing, orientation }), [variant, size, spacing, orientation]);
+
+return (
+<ToggleGroupContext.Provider value={ctx}>
+<ToggleGroupPrimitive.Root
+ref={ref}
+orientation={orientation}
+data-slot="toggle-group"
+data-variant={variant}
+data-size={size}
+data-spacing={spacing}
+style={{ '--sb--gap': spacing }}
+className={cn(
+"rounded-lg data-[size=sm]:rounded-[min(var(--sb--radius-md),10px)] group/toggle-group flex w-fit flex-row items-center gap-[--spacing(var(--sb--gap))] data-vertical:flex-col data-vertical:items-stretch",
+className
+)}
+{...props}
+>
+{children}
+</ToggleGroupPrimitive.Root>
+</ToggleGroupContext.Provider>
+);
+});
+export default ToggleGroup;

package/src/lib/components/ui/tooltip/index.js

@@ -1,3 +1,3 @@
-export { default as Root } from "./tooltip.svelte";
-export { default as Trigger } from "./tooltip-trigger.svelte";
-export { default as Content } from "./tooltip-content.svelte";
+export { default as Root } from "./tooltip.jsx";
+export { default as Trigger } from "./tooltip-trigger.jsx";
+export { default as Content } from "./tooltip-content.jsx";

package/src/lib/components/ui/tooltip/tooltip-content.jsx

@@ -0,0 +1,21 @@
+import { forwardRef } from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import { cn } from "../../../utils/index.js";
+
+const TooltipContent = forwardRef(function TooltipContent({ className, sideOffset = 8, ...props }, ref) {
+return (
+<TooltipPrimitive.Portal>
+<TooltipPrimitive.Content
+ref={ref}
+data-slot="tooltip-content"
+sideOffset={sideOffset}
+className={cn(
+"font-sans bg-slate-700 text-white text-xs px-2.5 py-1.5 rounded-lg shadow-lg z-[10001] animate-in fade-in-0 zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
+className
+)}
+{...props}
+/>
+</TooltipPrimitive.Portal>
+);
+});
+export default TooltipContent;

package/src/lib/components/ui/tooltip/tooltip-trigger.jsx

@@ -0,0 +1,23 @@
+import { forwardRef } from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+
+const TooltipTrigger = forwardRef(function TooltipTrigger({ asChild, children, ...props }, ref) {
+if (asChild) {
+return (
+<TooltipPrimitive.Trigger ref={ref} asChild {...props}>
+{children}
+</TooltipPrimitive.Trigger>
+);
+}
+return (
+<TooltipPrimitive.Trigger ref={ref} asChild {...props}>
+<span
+tabIndex={-1}
+style={{ display: "inline-flex" }}
+>
+{children}
+</span>
+</TooltipPrimitive.Trigger>
+);
+});
+export default TooltipTrigger;

package/src/lib/components/ui/tooltip/tooltip.jsx

@@ -0,0 +1,11 @@
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+
+export default function Tooltip({ children, ...props }) {
+return (
+<TooltipPrimitive.Provider delayDuration={50}>
+<TooltipPrimitive.Root {...props}>
+{children}
+</TooltipPrimitive.Root>
+</TooltipPrimitive.Provider>
+);
+}

package/src/lib/components/ui/trigger-button/index.js

@@ -1,6 +1,6 @@
-import Root from "./trigger-button.svelte";
+import Root from "./trigger-button.jsx";
 
 export {
-  Root,
-  Root as TriggerButton,
+Root,
+Root as TriggerButton,
 };

package/src/lib/components/ui/trigger-button/trigger-button.css

@@ -0,0 +1,38 @@
+[data-trigger-button] {
+  display: inline-flex;
+  position: relative;
+}
+[data-trigger-button] [data-slot="button-wrapper"] {
+  --sb--sc-border-color: var(--sb--trigger-border, var(--color-slate-400));
+  --sb--sc-border-width: var(--sb--trigger-border-width, 3px);
+}
+/* Accent-colored border/gap on focus — follows the superellipse shape */
+[data-trigger-button] [data-slot="button-wrapper"]:has([data-slot="button"]:focus-visible) {
+  --sb--sc-border-color: hsl(212 92% 45%);
+}
+[data-trigger-button] [data-slot="button"] {
+  background-color: var(--sb--trigger-bg, var(--color-slate-100));
+  color: var(--sb--trigger-text, var(--color-slate-600));
+}
+[data-trigger-button] [data-slot="button"]:hover,
+[data-trigger-button] [data-slot="button"]:focus-visible,
+[data-trigger-button] [data-slot="button"][aria-expanded="true"],
+[data-trigger-button][data-active] [data-slot="button"] {
+  background-color: var(--sb--trigger-bg-hover, var(--color-slate-300));
+}
+
+/* Inactive: disabled-looking, no interaction */
+[data-trigger-button][data-inactive] {
+  opacity: 0.45;
+  pointer-events: none;
+}
+
+/* Dimmed: reduced visibility, interactive on hover/focus */
+[data-trigger-button][data-dimmed] {
+  opacity: 0.3;
+  transition: opacity 200ms;
+}
+[data-trigger-button][data-dimmed]:hover,
+[data-trigger-button][data-dimmed]:focus-within {
+  opacity: 1;
+}

package/src/lib/components/ui/trigger-button/trigger-button.jsx

@@ -0,0 +1,63 @@
+import './trigger-button.css';
+import { useMemo, forwardRef } from "react";
+import { cn } from "../../../utils/index.js";
+import { registerSmoothCorners } from '../../../../smoothCorners.js';
+import { Button } from '../../../components/ui/button/index.js';
+
+registerSmoothCorners();
+
+const TriggerButton = forwardRef(function TriggerButton({
+className,
+wrapperClass = "",
+active = false,
+inactive = false,
+dimmed = false,
+localOnly = false,
+size = "icon-2xl",
+children,
+// Separate Radix trigger props from button props
+'aria-expanded': ariaExpanded,
+'data-state': dataState,
+'aria-haspopup': ariaHaspopup,
+...props
+}, ref) {
+const borderWidth = useMemo(
+() => ['icon-2xl', 'icon-xl', '2xl', 'xl'].includes(size) ? '3px' : '2px',
+[size]
+);
+
+return (
+<span
+ref={ref}
+data-trigger-button=""
+data-active={active || undefined}
+data-inactive={inactive || undefined}
+data-dimmed={dimmed || undefined}
+data-local-only={localOnly || undefined}
+style={{ '--sb--trigger-border-width': borderWidth }}
+aria-expanded={ariaExpanded}
+data-state={dataState}
+aria-haspopup={ariaHaspopup}
+>
+<Button
+variant="trigger"
+size={size}
+disabled={inactive}
+wrapperClass={cn(
+"smooth-corners [--sb--smooth-corners:4] hover:rotate-2 focus-visible:rotate-2 transition-transform",
+active && !inactive && "rotate-2",
+wrapperClass
+)}
+className={cn(
+"smooth-corners leading-none font-semibold",
+className
+)}
+{...props}
+>
+{children}
+</Button>
+</span>
+);
+});
+
+export default TriggerButton;

package/src/logger/devLogger.js

@@ -0,0 +1,238 @@
+/**
+ * Dev Logger — structured JSONL logging for storyboard dev server errors.
+ *
+ * Writes one JSONL file per day to `.storyboard/logs/{YYYY-MM-DD}.jsonl`.
+ * Automatically enriches log entries with context extracted from request URLs
+ * (canvas name, prototype, page, etc.).
+ *
+ * Usage:
+ *   import { createDevLogger } from './logger/devLogger.js'
+ *   const logger = createDevLogger({ root, devDomain, branch })
+ *   logger.logResponse({ status: 404, method: 'GET', url: '/...', route: 'canvas', error: '...' })
+ *   logger.logEvent('warn', 'Something happened', { extra: 'context' })
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+const LOGS_DIR_NAME = 'logs'
+const STORYBOARD_DIR = '.storyboard'
+const MAX_AGE_DAYS = 7
+
+/**
+ * Format a Date as YYYY-MM-DD.
+ */
+function dateStamp(date = new Date()) {
+  return date.toISOString().slice(0, 10)
+}
+
+/**
+ * Extract contextual metadata from a request URL.
+ * Parses query params and path segments to find canvas, prototype, and page.
+ */
+function extractContext(url) {
+  const ctx = { canvas: null, prototype: null, page: null }
+  if (!url) return ctx
+
+  try {
+    const parsed = new URL(url, 'http://localhost')
+    const params = parsed.searchParams
+
+    // Canvas name from ?name= query param (used by canvas CRUD routes)
+    if (params.has('name')) ctx.canvas = params.get('name')
+
+    // Prototype from path: /PrototypeName/... or ?prototype=
+    if (params.has('prototype')) ctx.prototype = params.get('prototype')
+
+    // Page from path segments or ?page=
+    if (params.has('page')) ctx.page = params.get('page')
+
+    // Infer from path: /_storyboard/canvas/... → canvas route
+    const pathname = parsed.pathname
+    if (!ctx.canvas && pathname.includes('/canvas/')) {
+      const segments = pathname.split('/').filter(Boolean)
+      const canvasIdx = segments.indexOf('canvas')
+      if (canvasIdx >= 0 && segments[canvasIdx + 1]) {
+        const sub = segments[canvasIdx + 1]
+        // Skip known sub-routes
+        if (!['read', 'list', 'update', 'widget', 'create', 'folders',
+              'connector', 'stories', 'create-story', 'github', 'image',
+              'images', 'terminal-buffer', 'terminal-snapshot',
+              'rename-page', 'reorder-pages', 'page-order',
+              'update-folder-meta', 'duplicate', 'image-proxy'].includes(sub)) {
+          ctx.canvas = sub
+        }
+      }
+    }
+  } catch {
+    // URL parsing failed — return empty context
+  }
+
+  return ctx
+}
+
+/**
+ * Prune log files older than MAX_AGE_DAYS.
+ */
+function pruneOldLogs(logsDir) {
+  try {
+    const files = fs.readdirSync(logsDir)
+    const cutoff = Date.now() - MAX_AGE_DAYS * 24 * 60 * 60 * 1000
+
+    for (const file of files) {
+      if (!file.endsWith('.jsonl')) continue
+      const dateStr = file.replace('.jsonl', '')
+      const fileDate = new Date(dateStr + 'T00:00:00Z')
+      if (isNaN(fileDate.getTime())) continue
+      if (fileDate.getTime() < cutoff) {
+        try {
+          fs.unlinkSync(path.join(logsDir, file))
+        } catch { /* best-effort */ }
+      }
+    }
+  } catch {
+    // Directory might not exist yet — that's fine
+  }
+}
+
+/**
+ * Create a dev logger instance.
+ *
+ * @param {object} opts
+ * @param {string} opts.root — project root directory
+ * @param {string} [opts.devDomain] — dev domain from config (e.g. "storyboard-core")
+ * @param {string} [opts.branch] — current git branch
+ * @param {boolean} [opts.verbose] — also log to console (controlled by dev-logs flag)
+ * @returns {{ logResponse: Function, logEvent: Function, logsDir: string }}
+ */
+export function createDevLogger({ root, devDomain = null, branch = null, verbose = false } = {}) {
+  const logsDir = path.join(root, STORYBOARD_DIR, LOGS_DIR_NAME)
+  let dirEnsured = false
+
+  function ensureDir() {
+    if (dirEnsured) return true
+    try {
+      fs.mkdirSync(logsDir, { recursive: true })
+      dirEnsured = true
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  // Prune old logs on startup (non-blocking, best-effort)
+  try { pruneOldLogs(logsDir) } catch { /* ignore */ }
+
+  function writeEntry(entry) {
+    if (!ensureDir()) return
+    const filename = `${dateStamp()}.jsonl`
+    const filepath = path.join(logsDir, filename)
+    const line = JSON.stringify(entry) + '\n'
+
+    try {
+      fs.appendFileSync(filepath, line, 'utf-8')
+    } catch {
+      // If we can't write logs, fail silently — never crash the server
+    }
+
+    if (verbose) {
+      const tag = entry.status ? `[${entry.status}]` : `[${entry.level}]`
+      const msg = entry.error || entry.message || ''
+      console.warn(`[storyboard-logs] ${tag} ${entry.method || ''} ${entry.url || ''} — ${msg}`)
+    }
+  }
+
+  /**
+   * Log an HTTP error response (4xx/5xx).
+   *
+   * @param {object} opts
+   * @param {number} opts.status — HTTP status code
+   * @param {string} opts.method — HTTP method (GET, POST, etc.)
+   * @param {string} opts.url — full request URL
+   * @param {string} [opts.route] — top-level route prefix (e.g. "canvas", "workshop")
+   * @param {string} [opts.subRoute] — sub-route path after prefix
+   * @param {string} [opts.error] — error message from the response body
+   * @param {object} [opts.context] — additional context (overrides auto-extracted)
+   */
+  function logResponse({ status, method, url, route = null, subRoute = null, error = null, context = {} }) {
+    if (status < 400) return
+
+    const autoContext = extractContext(url)
+    const mergedContext = { ...autoContext, ...context }
+
+    // Strip null values from context
+    for (const key of Object.keys(mergedContext)) {
+      if (mergedContext[key] == null) delete mergedContext[key]
+    }
+
+    const entry = {
+      ts: new Date().toISOString(),
+      level: status >= 500 ? 'error' : 'warn',
+      status,
+      method: method || 'UNKNOWN',
+      url: url || '',
+      route: route || null,
+      subRoute: subRoute || null,
+      error: error || null,
+      devDomain: devDomain || null,
+      branch: branch || null,
+    }
+
+    if (Object.keys(mergedContext).length > 0) {
+      entry.context = mergedContext
+    }
+
+    writeEntry(entry)
+  }
+
+  /**
+   * Log a general event (not tied to an HTTP response).
+   *
+   * @param {'info'|'warn'|'error'} level
+   * @param {string} message
+   * @param {object} [context] — arbitrary context data
+   */
+  function logEvent(level, message, context = {}) {
+    const entry = {
+      ts: new Date().toISOString(),
+      level,
+      message,
+      devDomain: devDomain || null,
+      branch: branch || null,
+    }
+    if (Object.keys(context).length > 0) {
+      entry.context = context
+    }
+    writeEntry(entry)
+  }
+
+  return { logResponse, logEvent, logsDir, _extractContext: extractContext }
+}
+
+// ─── Module-level singleton ───
+// Set once by server-plugin.js, then any server-side module can call devLog().
+
+let _instance = null
+
+/**
+ * Register the global dev logger instance.
+ * Called once during server startup (server-plugin.js configureServer).
+ */
+export function setDevLogger(logger) {
+  _instance = logger
+}
+
+/**
+ * Get the global dev logger. Returns a no-op logger if not yet initialized.
+ * Safe to call from any server-side module without constructor plumbing.
+ */
+export function devLog() {
+  return _instance || _noop
+}
+
+const _noop = {
+  logResponse() {},
+  logEvent() {},
+}
+
+export { extractContext, pruneOldLogs, dateStamp }

package/src/logger/devLogger.test.js

@@ -0,0 +1,193 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { createDevLogger, extractContext, pruneOldLogs, dateStamp } from './devLogger.js'
+
+function makeTmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'devlogger-test-'))
+}
+
+describe('devLogger', () => {
+  let tmpRoot
+
+  beforeEach(() => {
+    tmpRoot = makeTmpDir()
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpRoot, { recursive: true, force: true })
+  })
+
+  describe('createDevLogger', () => {
+    it('creates the logs directory on first write', () => {
+      const logger = createDevLogger({ root: tmpRoot, devDomain: 'test', branch: 'main' })
+      const logsDir = path.join(tmpRoot, '.storyboard', 'logs')
+
+      // Not created yet (lazy)
+      expect(fs.existsSync(logsDir)).toBe(false)
+
+      logger.logResponse({ status: 404, method: 'GET', url: '/_storyboard/canvas/read?name=missing', error: 'Not found' })
+
+      expect(fs.existsSync(logsDir)).toBe(true)
+    })
+
+    it('writes JSONL entries with correct format', () => {
+      const logger = createDevLogger({ root: tmpRoot, devDomain: 'test-domain', branch: 'feat-x' })
+
+      logger.logResponse({
+        status: 404,
+        method: 'GET',
+        url: '/_storyboard/canvas/read?name=my-canvas',
+        route: 'canvas',
+        subRoute: '/read',
+        error: 'Canvas "my-canvas" not found',
+      })
+
+      const logsDir = path.join(tmpRoot, '.storyboard', 'logs')
+      const files = fs.readdirSync(logsDir)
+      expect(files).toHaveLength(1)
+      expect(files[0]).toMatch(/^\d{4}-\d{2}-\d{2}\.jsonl$/)
+
+      const content = fs.readFileSync(path.join(logsDir, files[0]), 'utf-8')
+      const lines = content.trim().split('\n')
+      expect(lines).toHaveLength(1)
+
+      const entry = JSON.parse(lines[0])
+      expect(entry.ts).toMatch(/^\d{4}-\d{2}-\d{2}T/)
+      expect(entry.level).toBe('warn')
+      expect(entry.status).toBe(404)
+      expect(entry.method).toBe('GET')
+      expect(entry.route).toBe('canvas')
+      expect(entry.subRoute).toBe('/read')
+      expect(entry.error).toBe('Canvas "my-canvas" not found')
+      expect(entry.devDomain).toBe('test-domain')
+      expect(entry.branch).toBe('feat-x')
+      expect(entry.context.canvas).toBe('my-canvas')
+    })
+
+    it('uses level "error" for 5xx status codes', () => {
+      const logger = createDevLogger({ root: tmpRoot })
+      logger.logResponse({ status: 500, method: 'POST', url: '/test', error: 'Internal error' })
+
+      const logsDir = path.join(tmpRoot, '.storyboard', 'logs')
+      const files = fs.readdirSync(logsDir)
+      const entry = JSON.parse(fs.readFileSync(path.join(logsDir, files[0]), 'utf-8').trim())
+      expect(entry.level).toBe('error')
+    })
+
+    it('does not log 2xx responses', () => {
+      const logger = createDevLogger({ root: tmpRoot })
+      logger.logResponse({ status: 200, method: 'GET', url: '/ok' })
+      logger.logResponse({ status: 201, method: 'POST', url: '/created' })
+
+      const logsDir = path.join(tmpRoot, '.storyboard', 'logs')
+      expect(fs.existsSync(logsDir)).toBe(false) // never written, dir never created
+    })
+
+    it('appends multiple entries to the same day file', () => {
+      const logger = createDevLogger({ root: tmpRoot })
+      logger.logResponse({ status: 404, method: 'GET', url: '/a', error: 'A' })
+      logger.logResponse({ status: 400, method: 'POST', url: '/b', error: 'B' })
+      logger.logResponse({ status: 502, method: 'GET', url: '/c', error: 'C' })
+
+      const logsDir = path.join(tmpRoot, '.storyboard', 'logs')
+      const files = fs.readdirSync(logsDir)
+      expect(files).toHaveLength(1)
+
+      const lines = fs.readFileSync(path.join(logsDir, files[0]), 'utf-8').trim().split('\n')
+      expect(lines).toHaveLength(3)
+      expect(JSON.parse(lines[0]).error).toBe('A')
+      expect(JSON.parse(lines[1]).error).toBe('B')
+      expect(JSON.parse(lines[2]).error).toBe('C')
+    })
+  })
+
+  describe('logEvent', () => {
+    it('logs general events with level and message', () => {
+      const logger = createDevLogger({ root: tmpRoot, devDomain: 'test' })
+      logger.logEvent('warn', 'Hot pool failed to start', { poolId: 'copilot' })
+
+      const logsDir = path.join(tmpRoot, '.storyboard', 'logs')
+      const files = fs.readdirSync(logsDir)
+      const entry = JSON.parse(fs.readFileSync(path.join(logsDir, files[0]), 'utf-8').trim())
+
+      expect(entry.level).toBe('warn')
+      expect(entry.message).toBe('Hot pool failed to start')
+      expect(entry.context.poolId).toBe('copilot')
+      expect(entry.devDomain).toBe('test')
+    })
+  })
+
+  describe('extractContext', () => {
+    it('extracts canvas name from ?name= query param', () => {
+      const ctx = extractContext('/_storyboard/canvas/read?name=design-system')
+      expect(ctx.canvas).toBe('design-system')
+    })
+
+    it('extracts prototype from ?prototype= query param', () => {
+      const ctx = extractContext('/_storyboard/workshop/create?prototype=Dashboard')
+      expect(ctx.prototype).toBe('Dashboard')
+    })
+
+    it('extracts page from ?page= query param', () => {
+      const ctx = extractContext('/_storyboard/something?page=settings')
+      expect(ctx.page).toBe('settings')
+    })
+
+    it('returns empty context for non-parseable URLs', () => {
+      const ctx = extractContext('')
+      expect(ctx.canvas).toBeNull()
+      expect(ctx.prototype).toBeNull()
+      expect(ctx.page).toBeNull()
+    })
+
+    it('returns empty context for null input', () => {
+      const ctx = extractContext(null)
+      expect(ctx.canvas).toBeNull()
+    })
+  })
+
+  describe('dateStamp', () => {
+    it('returns YYYY-MM-DD format', () => {
+      const stamp = dateStamp(new Date('2026-04-25T12:00:00Z'))
+      expect(stamp).toBe('2026-04-25')
+    })
+  })
+
+  describe('pruneOldLogs', () => {
+    it('removes log files older than 7 days', () => {
+      const logsDir = path.join(tmpRoot, 'logs')
+      fs.mkdirSync(logsDir, { recursive: true })
+
+      // Create old file (10 days ago)
+      const old = new Date(Date.now() - 10 * 24 * 60 * 60 * 1000)
+      const oldFile = `${dateStamp(old)}.jsonl`
+      fs.writeFileSync(path.join(logsDir, oldFile), '{"test":true}\n')
+
+      // Create recent file (today)
+      const todayFile = `${dateStamp()}.jsonl`
+      fs.writeFileSync(path.join(logsDir, todayFile), '{"test":true}\n')
+
+      pruneOldLogs(logsDir)
+
+      const remaining = fs.readdirSync(logsDir)
+      expect(remaining).toContain(todayFile)
+      expect(remaining).not.toContain(oldFile)
+    })
+
+    it('ignores non-jsonl files', () => {
+      const logsDir = path.join(tmpRoot, 'logs')
+      fs.mkdirSync(logsDir, { recursive: true })
+      fs.writeFileSync(path.join(logsDir, 'readme.txt'), 'keep me')
+
+      pruneOldLogs(logsDir)
+
+      expect(fs.existsSync(path.join(logsDir, 'readme.txt'))).toBe(true)
+    })
+
+    it('handles non-existent directory gracefully', () => {
+      expect(() => pruneOldLogs(path.join(tmpRoot, 'nonexistent'))).not.toThrow()
+    })
+  })
+})