@assistkick/create 1.0.0

package/templates/product-system/tests/search_reorder.test.ts

@@ -0,0 +1,88 @@
+/**
+ * Tests for Reorder Search Above Type Filter (feat_028).
+ * Verifies that the search input is rendered inside the legend card,
+ * above the legend sections, and that existing search functionality is preserved.
+ * Updated for React frontend architecture.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SOURCE_ROOT = existsSync(join(__dirname, '..', 'package.json')) ? join(__dirname, '..') : join(__dirname, '..', '..');
+const htmlPath = join(SOURCE_ROOT, 'packages', 'frontend', 'index.html');
+const cssPath = join(SOURCE_ROOT, 'packages', 'frontend', 'src', 'styles', 'index.css');
+const legendPath = join(SOURCE_ROOT, 'packages', 'frontend', 'src', 'components', 'GraphLegend.tsx');
+
+const html = readFileSync(htmlPath, 'utf-8');
+const css = readFileSync(cssPath, 'utf-8');
+const legendSrc = readFileSync(legendPath, 'utf-8');
+
+describe('feat_028: Reorder Search Above Type Filter', () => {
+
+  describe('HTML structure', () => {
+    it('search-container is NOT in index.html (rendered by React component)', () => {
+      assert.ok(!html.includes('id="search-container"'),
+        'search-container should not be in index.html — it is rendered by GraphLegend component');
+    });
+
+    it('filter-bar is removed from index.html', () => {
+      assert.ok(!html.includes('class="filter-bar"'),
+        'filter-bar should be removed from index.html');
+    });
+  });
+
+  describe('GraphLegend renders search', () => {
+    it('legend component includes search-container with id', () => {
+      assert.ok(legendSrc.includes('id="search-container"'),
+        'GraphLegend should render an element with id="search-container"');
+    });
+
+    it('legend renders search input with search-input class', () => {
+      assert.ok(legendSrc.includes('className="search-input"'),
+        'GraphLegend should render search input');
+    });
+
+    it('legend does NOT render type select dropdown (removed per rejection)', () => {
+      assert.ok(!legendSrc.includes('search-type-select'),
+        'GraphLegend should not render a type select dropdown');
+    });
+
+    it('legend does NOT render search-results dropdown (removed per feat_035)', () => {
+      assert.ok(!legendSrc.includes('search-results'),
+        'GraphLegend should not render search results dropdown — search dims nodes directly');
+    });
+
+    it('search container appears before the legend-header in JSX', () => {
+      const searchIdx = legendSrc.indexOf('legend-search-container');
+      const headerIdx = legendSrc.indexOf('legend-header');
+      assert.ok(searchIdx > -1, 'legend-search-container should exist in component');
+      assert.ok(headerIdx > -1, 'legend-header should exist in component');
+      assert.ok(searchIdx < headerIdx,
+        'search container should appear before the legend header (above legend sections)');
+    });
+  });
+
+  describe('CSS layout', () => {
+    it('legend-search-container has display flex', () => {
+      const rule = css.match(/\.legend-search-container\s*\{([^}]+)\}/);
+      assert.ok(rule, 'legend-search-container CSS rule should exist');
+      assert.ok(rule[1].includes('display: flex'),
+        'legend-search-container should use display: flex');
+    });
+
+    it('search input uses flex: 1 to span full width', () => {
+      assert.ok(css.includes('.legend-search-container .search-input'),
+        'search-input inside legend should have specific styling');
+    });
+
+    it('side panel top is 44px without filter bar', () => {
+      const panelRule = css.match(/\.side-panel\s*\{([^}]+)\}/);
+      assert.ok(panelRule, 'side-panel CSS block should exist');
+      assert.ok(panelRule[1].includes('top: 44px'),
+        'side panel top should be 44px');
+    });
+  });
+});

package/templates/product-system/tests/serve_ui.test.ts

@@ -0,0 +1,281 @@
+/**
+ * Tests for serve_ui.ts server endpoints and UI classes.
+ * Uses node:test built-in runner.
+ */
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { createServer } from 'node:http';
+import { readFile } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SKILL_DIR = join(__dirname, '..');
+
+// In-memory test fixtures (data lives in DB now, not files)
+const TEST_GRAPH = {
+  project: { name: 'Test Project' },
+  nodes: [
+    { id: 'comp_001', type: 'component', name: 'Test Component', completeness: 0.5, open_questions_count: 1 },
+    { id: 'feat_001', type: 'feature', name: 'Test Feature', completeness: 1, open_questions_count: 0 },
+  ],
+  edges: [
+    { from: 'feat_001', to: 'comp_001', relation: 'contains' },
+  ],
+};
+
+const TEST_NODES = {
+  comp_001: '---\nid: comp_001\ntype: component\nname: Test Component\n---\nBody content here.',
+};
+
+const TEST_KANBAN = {
+  feat_001: { column: 'done', rejection_count: 0, notes: [] },
+};
+
+// Helper: start the server for integration tests
+const startTestServer = async () => {
+  const { createServer: createHttp } = await import('node:http');
+  const { readFile: rf, stat: st } = await import('node:fs/promises');
+
+  const UI_DIR = join(SKILL_DIR, 'packages', 'frontend');
+
+  const sendJson = (res, statusCode, data) => {
+    const body = JSON.stringify(data);
+    res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+    res.end(body);
+  };
+
+  const routeRequest = async (req, res) => {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const path = url.pathname;
+
+    if (path === '/api/graph') {
+      sendJson(res, 200, TEST_GRAPH);
+      return;
+    }
+
+    const nodeMatch = path.match(/^\/api\/node\/([a-z_]+\d+)$/);
+    if (nodeMatch) {
+      const nodeId = nodeMatch[1];
+      const content = TEST_NODES[nodeId];
+      if (content) {
+        sendJson(res, 200, { id: nodeId, content });
+      } else {
+        sendJson(res, 404, { error: `Node not found: ${nodeId}` });
+      }
+      return;
+    }
+
+    if (path === '/api/kanban') {
+      sendJson(res, 200, TEST_KANBAN);
+      return;
+    }
+
+    const filePath = path === '/' ? join(UI_DIR, 'index.html') : join(UI_DIR, path);
+    if (!filePath.startsWith(UI_DIR)) {
+      res.writeHead(403);
+      res.end('Forbidden');
+      return;
+    }
+
+    try {
+      const info = await st(filePath);
+      if (!info.isFile()) { res.writeHead(404); res.end('Not found'); return; }
+      const content = await rf(filePath);
+      const ext = filePath.split('.').pop();
+      const mimeMap = { html: 'text/html', js: 'application/javascript', css: 'text/css' };
+      res.writeHead(200, { 'Content-Type': mimeMap[ext] || 'application/octet-stream' });
+      res.end(content);
+    } catch {
+      res.writeHead(404);
+      res.end('Not found');
+    }
+  };
+
+  const server = createHttp(routeRequest);
+  await new Promise(resolve => server.listen(0, resolve));
+  const port = server.address().port;
+  return { server, port, baseUrl: `http://localhost:${port}` };
+};
+
+describe('Server API', () => {
+  let server, port, baseUrl;
+
+  beforeEach(async () => {
+    const s = await startTestServer();
+    server = s.server;
+    port = s.port;
+    baseUrl = s.baseUrl;
+  });
+
+  afterEach(() => {
+    server.close();
+  });
+
+  it('GET /api/graph returns valid graph JSON', async () => {
+    const resp = await fetch(`${baseUrl}/api/graph`);
+    assert.equal(resp.status, 200);
+    const data = await resp.json();
+    assert.ok(data.nodes, 'graph should have nodes array');
+    assert.ok(data.edges, 'graph should have edges array');
+    assert.ok(data.project, 'graph should have project object');
+  });
+
+  it('GET /api/node/:id returns node content for existing node', async () => {
+    const resp = await fetch(`${baseUrl}/api/node/comp_001`);
+    assert.equal(resp.status, 200);
+    const data = await resp.json();
+    assert.equal(data.id, 'comp_001');
+    assert.ok(data.content, 'should have content field');
+  });
+
+  it('GET /api/node/:id returns 404 for non-existent node', async () => {
+    const resp = await fetch(`${baseUrl}/api/node/nonexistent_999`);
+    assert.equal(resp.status, 404);
+    const data = await resp.json();
+    assert.ok(data.error);
+  });
+
+  it('GET /api/kanban returns valid kanban JSON', async () => {
+    const resp = await fetch(`${baseUrl}/api/kanban`);
+    assert.equal(resp.status, 200);
+    const data = await resp.json();
+    assert.ok(typeof data === 'object', 'kanban should be an object');
+  });
+
+  it('GET / serves index.html', async () => {
+    const resp = await fetch(`${baseUrl}/`);
+    assert.equal(resp.status, 200);
+    const ct = resp.headers.get('content-type');
+    assert.ok(ct.includes('text/html'));
+  });
+
+  it('GET /src/styles/index.css serves CSS file', async () => {
+    const resp = await fetch(`${baseUrl}/src/styles/index.css`);
+    assert.equal(resp.status, 200);
+    const ct = resp.headers.get('content-type');
+    assert.ok(ct.includes('text/css'));
+  });
+
+  it('GET /nonexistent returns 404', async () => {
+    const resp = await fetch(`${baseUrl}/does_not_exist.xyz`);
+    assert.equal(resp.status, 404);
+  });
+
+  it('rejects directory traversal attempts', async () => {
+    const resp = await fetch(`${baseUrl}/../graph.json`);
+    // URL normalization may resolve this differently, but we should not serve graph.json
+    assert.notEqual(resp.headers.get('content-type'), 'application/json');
+  });
+});
+
+describe('ThemeManager', () => {
+  it('defaults to dark theme when storage is empty', () => {
+    const storage = { getItem: () => null, setItem: () => {} };
+    const root = { setAttribute: () => {} };
+    const toggle = null;
+
+    // Inline the logic for testing
+    const theme = storage.getItem('graph-ui-theme') || 'dark';
+    assert.equal(theme, 'dark');
+  });
+
+  it('reads theme from storage', () => {
+    const storage = { getItem: (key) => key === 'graph-ui-theme' ? 'light' : null, setItem: () => {} };
+    const theme = storage.getItem('graph-ui-theme') || 'dark';
+    assert.equal(theme, 'light');
+  });
+
+  it('toggles between dark and light', () => {
+    let current = 'dark';
+    const toggle = () => { current = current === 'dark' ? 'light' : 'dark'; };
+    toggle();
+    assert.equal(current, 'light');
+    toggle();
+    assert.equal(current, 'dark');
+  });
+});
+
+describe('GraphRenderer data transformations', () => {
+  const sampleGraph = {
+    nodes: [
+      { id: 'feat_001', type: 'feature', name: 'Node A', completeness: 1, open_questions_count: 0 },
+      { id: 'comp_001', type: 'component', name: 'Node B', completeness: 0.5, open_questions_count: 2 },
+      { id: 'dec_001', type: 'decision', name: 'Node C', completeness: 0.8, open_questions_count: 0 },
+    ],
+    edges: [
+      { from: 'feat_001', to: 'comp_001', relation: 'contains' },
+      { from: 'feat_001', to: 'dec_001', relation: 'governed_by' },
+    ],
+  };
+
+  it('computes edge counts for nodes', () => {
+    const edgeCounts = new Map();
+    sampleGraph.edges.forEach(e => {
+      edgeCounts.set(e.from, (edgeCounts.get(e.from) || 0) + 1);
+      edgeCounts.set(e.to, (edgeCounts.get(e.to) || 0) + 1);
+    });
+
+    assert.equal(edgeCounts.get('feat_001'), 2);
+    assert.equal(edgeCounts.get('comp_001'), 1);
+    assert.equal(edgeCounts.get('dec_001'), 1);
+  });
+
+  it('filters links to only include existing nodes', () => {
+    const nodeIds = new Set(sampleGraph.nodes.map(n => n.id));
+    const extraEdges = [
+      ...sampleGraph.edges,
+      { from: 'feat_001', to: 'nonexistent_001', relation: 'contains' },
+    ];
+    const validLinks = extraEdges.filter(e => nodeIds.has(e.from) && nodeIds.has(e.to));
+    assert.equal(validLinks.length, 2);
+  });
+
+  it('computes node radius based on edge count', () => {
+    const nodeRadius = (edgeCount) => {
+      const base = 8;
+      const scale = Math.min(edgeCount * 1.5, 20);
+      return base + scale;
+    };
+
+    assert.equal(nodeRadius(0), 8);
+    assert.equal(nodeRadius(2), 11);
+    assert.equal(nodeRadius(20), 28); // capped at 20
+  });
+
+  it('computes node stroke for gaps', () => {
+    const nodeStroke = (d) => {
+      if (d.completeness < 1 && d.open_questions_count > 0) return '#ff6b6b';
+      if (d.completeness < 1) return '#ffd43b';
+      return 'transparent';
+    };
+
+    assert.equal(nodeStroke({ completeness: 1, open_questions_count: 0 }), 'transparent');
+    assert.equal(nodeStroke({ completeness: 0.5, open_questions_count: 2 }), '#ff6b6b');
+    assert.equal(nodeStroke({ completeness: 0.8, open_questions_count: 0 }), '#ffd43b');
+  });
+
+  it('computes overall completeness percentage', () => {
+    const nodes = sampleGraph.nodes;
+    const total = nodes.length;
+    const sum = nodes.reduce((acc, n) => acc + (n.completeness || 0), 0);
+    const pct = Math.round((sum / total) * 100);
+    assert.equal(pct, 77); // (1 + 0.5 + 0.8) / 3 = 0.7666...
+  });
+});
+
+describe('ApiClient', () => {
+  it('constructs URLs correctly with base URL', () => {
+    const baseUrl = 'http://localhost:3000';
+    const graphUrl = `${baseUrl}/api/graph`;
+    const nodeUrl = `${baseUrl}/api/node/feat_001`;
+    assert.equal(graphUrl, 'http://localhost:3000/api/graph');
+    assert.equal(nodeUrl, 'http://localhost:3000/api/node/feat_001');
+  });
+
+  it('constructs URLs correctly with empty base URL', () => {
+    const baseUrl = '';
+    const graphUrl = `${baseUrl}/api/graph`;
+    assert.equal(graphUrl, '/api/graph');
+  });
+});

package/templates/product-system/tests/serve_ui_drizzle.test.ts

@@ -0,0 +1,114 @@
+/**
+ * Tests for backend Drizzle integration (originally feat_047).
+ * Verifies that the backend API routes use the Drizzle data access layer.
+ * Uses node:test built-in runner.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SOURCE_ROOT = join(__dirname, '..');
+const BACKEND_SRC = join(SOURCE_ROOT, 'packages', 'backend', 'src');
+const SHARED_LIB = join(SOURCE_ROOT, 'packages', 'shared', 'lib');
+
+describe('Backend Drizzle integration', () => {
+  let graphRouteContent: string;
+  let kanbanRouteContent: string;
+  let coherenceRouteContent: string;
+  let serverContent: string;
+
+  it('loads backend source files', async () => {
+    graphRouteContent = await readFile(join(BACKEND_SRC, 'routes', 'graph.ts'), 'utf-8');
+    kanbanRouteContent = await readFile(join(BACKEND_SRC, 'routes', 'kanban.ts'), 'utf-8');
+    coherenceRouteContent = await readFile(join(BACKEND_SRC, 'routes', 'coherence.ts'), 'utf-8');
+    serverContent = await readFile(join(BACKEND_SRC, 'server.ts'), 'utf-8');
+    assert.ok(graphRouteContent.length > 0);
+    assert.ok(kanbanRouteContent.length > 0);
+    assert.ok(coherenceRouteContent.length > 0);
+    assert.ok(serverContent.length > 0);
+  });
+
+  it('graph route uses readGraph()', () => {
+    assert.ok(graphRouteContent.includes('readGraph'), 'graph route should use readGraph');
+  });
+
+  it('graph route uses getDb() for node content', () => {
+    assert.ok(graphRouteContent.includes('getDb'), 'graph route should use getDb');
+  });
+
+  it('kanban route uses loadKanban()', () => {
+    assert.ok(kanbanRouteContent.includes('loadKanban'), 'kanban route should use loadKanban');
+  });
+
+  it('kanban route uses saveKanbanEntry()', () => {
+    assert.ok(kanbanRouteContent.includes('saveKanbanEntry'), 'kanban route should use saveKanbanEntry');
+  });
+
+  it('coherence route uses loadCoherence()', () => {
+    assert.ok(
+      coherenceRouteContent.includes('readCoherenceData') || coherenceRouteContent.includes('loadCoherence'),
+      'coherence route should load coherence data from DB'
+    );
+  });
+
+  it('server uses Express', () => {
+    assert.ok(serverContent.includes('express'), 'server should use Express');
+  });
+
+  it('backend does NOT use writeFile for data persistence', () => {
+    assert.ok(!graphRouteContent.includes('writeFile'), 'graph route should not use writeFile');
+    assert.ok(!kanbanRouteContent.includes('writeFile'), 'kanban route should not use writeFile');
+  });
+});
+
+describe('coherence.ts module structure', () => {
+  let coherenceContent: string;
+
+  it('loads coherence.ts source', async () => {
+    const coherencePath = join(SHARED_LIB, 'coherence.ts');
+    coherenceContent = await readFile(coherencePath, 'utf-8');
+    assert.ok(coherenceContent.length > 0);
+  });
+
+  it('exports loadCoherence function', () => {
+    assert.ok(coherenceContent.includes('export const loadCoherence'), 'should export loadCoherence');
+  });
+
+  it('exports saveCoherence function', () => {
+    assert.ok(coherenceContent.includes('export const saveCoherence'), 'should export saveCoherence');
+  });
+
+  it('exports getProposal function', () => {
+    assert.ok(coherenceContent.includes('export const getProposal'), 'should export getProposal');
+  });
+
+  it('exports updateProposalStatus function', () => {
+    assert.ok(coherenceContent.includes('export const updateProposalStatus'), 'should export updateProposalStatus');
+  });
+
+  it('exports updateCoherenceState function', () => {
+    assert.ok(coherenceContent.includes('export const updateCoherenceState'), 'should export updateCoherenceState');
+  });
+
+  it('exports addProposals function', () => {
+    assert.ok(coherenceContent.includes('export const addProposals'), 'should export addProposals');
+  });
+
+  it('uses coherenceReviews table from schema', () => {
+    assert.ok(
+      coherenceContent.includes("import { coherenceReviews, reviewMeta }"),
+      'should import coherenceReviews and reviewMeta from schema'
+    );
+  });
+
+  it('uses getDb from lib/db.ts', () => {
+    assert.ok(coherenceContent.includes("import { getDb }"), 'should import getDb from db.ts');
+  });
+
+  it('uses review_meta for coherence state', () => {
+    assert.ok(coherenceContent.includes("coherence:state"), 'should use coherence:state key in review_meta');
+  });
+});

package/templates/product-system/tests/session_context_recall.test.ts

@@ -0,0 +1,135 @@
+/**
+ * Unit tests for session context recall (feat_058).
+ * Tests data transformations and formatting without requiring Drizzle/Turso.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+/**
+ * Helper: extractDescriptionExcerpt — mirrors the function in start_session.js.
+ */
+const extractDescriptionExcerpt = (body, maxLen = 120) => {
+  if (!body) return '';
+  const match = body.match(/## Description\s*\n+(.+)/);
+  if (!match) return '';
+  const line = match[1].trim();
+  return line.length > maxLen ? line.slice(0, maxLen) + '…' : line;
+};
+
+describe('session context recall', () => {
+  describe('extractDescriptionExcerpt', () => {
+    it('extracts first line after ## Description', () => {
+      const body = '## Description\nThis is the description line.\n\n## Other Section\nstuff';
+      assert.equal(extractDescriptionExcerpt(body), 'This is the description line.');
+    });
+
+    it('truncates long descriptions with ellipsis', () => {
+      const longLine = 'A'.repeat(200);
+      const body = `## Description\n${longLine}\n`;
+      const result = extractDescriptionExcerpt(body, 120);
+      assert.equal(result.length, 121); // 120 chars + ellipsis
+      assert.ok(result.endsWith('…'));
+    });
+
+    it('returns empty string for null body', () => {
+      assert.equal(extractDescriptionExcerpt(null), '');
+    });
+
+    it('returns empty string when no Description section exists', () => {
+      assert.equal(extractDescriptionExcerpt('## Other\nContent'), '');
+    });
+
+    it('handles blank lines between header and content', () => {
+      const body = '## Description\n\nActual content here.';
+      assert.equal(extractDescriptionExcerpt(body), 'Actual content here.');
+    });
+  });
+
+  describe('recent sessions data transformation', () => {
+    it('parses nodesTouched JSON from session records', () => {
+      const session = {
+        sessionNumber: 5,
+        startedAt: '2026-03-01T10:00:00.000Z',
+        endedAt: '2026-03-01T11:00:00.000Z',
+        summary: 'Worked on auth features',
+        nodesTouched: '["feat_001","feat_002","dec_003"]',
+        questionsResolved: 2,
+      };
+
+      const nodesTouched = JSON.parse(session.nodesTouched);
+      assert.deepEqual(nodesTouched, ['feat_001', 'feat_002', 'dec_003']);
+    });
+
+    it('handles null nodesTouched gracefully', () => {
+      const session = { nodesTouched: null };
+      const nodesTouched = session.nodesTouched ? JSON.parse(session.nodesTouched) : [];
+      assert.deepEqual(nodesTouched, []);
+    });
+
+    it('handles empty array nodesTouched', () => {
+      const session = { nodesTouched: '[]' };
+      const nodesTouched = JSON.parse(session.nodesTouched);
+      assert.deepEqual(nodesTouched, []);
+    });
+  });
+
+  describe('recent decisions filtering', () => {
+    it('filters decisions updated after earliest session start', () => {
+      const recentSessions = [
+        { startedAt: '2026-03-03T10:00:00.000Z', endedAt: '2026-03-03T11:00:00.000Z' },
+        { startedAt: '2026-03-02T10:00:00.000Z', endedAt: '2026-03-02T11:00:00.000Z' },
+        { startedAt: '2026-03-01T10:00:00.000Z', endedAt: '2026-03-01T11:00:00.000Z' },
+      ];
+      const earliest = recentSessions[recentSessions.length - 1].startedAt;
+
+      const allDecisions = [
+        { id: 'dec_001', name: 'Recent Decision', updatedAt: '2026-03-02T12:00:00.000Z' },
+        { id: 'dec_002', name: 'Old Decision', updatedAt: '2026-02-15T12:00:00.000Z' },
+        { id: 'dec_003', name: 'Another Recent', updatedAt: '2026-03-01T10:30:00.000Z' },
+      ];
+
+      const filtered = allDecisions.filter(d => d.updatedAt >= earliest);
+      assert.equal(filtered.length, 2);
+      assert.equal(filtered[0].id, 'dec_001');
+      assert.equal(filtered[1].id, 'dec_003');
+    });
+
+    it('returns empty when no sessions exist', () => {
+      const recentSessions = [];
+      assert.equal(recentSessions.length, 0);
+      // getRecentDecisions returns [] when recentSessions is empty
+    });
+  });
+
+  describe('recently modified nodes formatting', () => {
+    it('formats node data for concise display', () => {
+      const node = {
+        id: 'feat_042',
+        name: 'Search Feature',
+        type: 'feature',
+        status: 'defined',
+        completeness: 0.85,
+        updatedAt: '2026-03-03T14:30:00.000Z',
+      };
+
+      const formatted = `${node.id} ${node.name} [${node.type}] ${node.status} — ${Math.round(node.completeness * 100)}% (updated ${node.updatedAt})`;
+      assert.equal(formatted, 'feat_042 Search Feature [feature] defined — 85% (updated 2026-03-03T14:30:00.000Z)');
+    });
+  });
+
+  describe('context recall omission on first session', () => {
+    it('skips recall section when no ended sessions exist', () => {
+      const recentSessions = [];
+      const shouldShowRecall = recentSessions.length > 0;
+      assert.equal(shouldShowRecall, false);
+    });
+
+    it('shows recall section when ended sessions exist', () => {
+      const recentSessions = [
+        { sessionNumber: 1, startedAt: '2026-03-01T10:00:00.000Z', endedAt: '2026-03-01T11:00:00.000Z' },
+      ];
+      const shouldShowRecall = recentSessions.length > 0;
+      assert.equal(shouldShowRecall, true);
+    });
+  });
+});