@assistkick/create 1.0.0

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

@@ -0,0 +1,285 @@
+/**
+ * Tests for Node Type Toggle Filters (feat_029).
+ * Uses node:test built-in runner.
+ * Tests the filtering logic that hides/shows nodes by type using toggle chips.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+// Minimal renderer mock replicating buildNodes and buildLinks with hiddenTypes
+const createRenderer = (hiddenTypes = new Set()) => {
+  const renderer = {
+    hideDefinedActive: false,
+    hiddenTypes: new Set(hiddenTypes),
+
+    buildNodes: function (graphData) {
+      const edgeCounts = new Map();
+      graphData.edges.forEach(e => {
+        edgeCounts.set(e.from, (edgeCounts.get(e.from) || 0) + 1);
+        edgeCounts.set(e.to, (edgeCounts.get(e.to) || 0) + 1);
+      });
+
+      let nodes = graphData.nodes.map(n => ({
+        ...n,
+        edgeCount: edgeCounts.get(n.id) || 0,
+      }));
+
+      if (this.hideDefinedActive) {
+        nodes = nodes.filter(n => !(n.status === 'defined' && n.completeness === 1));
+      }
+
+      if (this.hiddenTypes.size > 0) {
+        nodes = nodes.filter(n => !this.hiddenTypes.has(n.type));
+      }
+
+      return nodes;
+    },
+
+    buildLinks: function (graphData, nodes) {
+      const nodeIds = new Set(nodes.map(n => n.id));
+      return graphData.edges
+        .filter(e => nodeIds.has(e.from) && nodeIds.has(e.to))
+        .map(e => ({
+          source: e.from,
+          target: e.to,
+          relation: e.relation,
+        }));
+    },
+
+    setHiddenTypes: function (hiddenTypes) {
+      this.hiddenTypes = new Set(hiddenTypes);
+    },
+  };
+  return renderer;
+};
+
+// Test fixtures
+const makeGraphData = () => ({
+  nodes: [
+    { id: 'feat_001', type: 'feature', name: 'Feature A', status: 'defined', completeness: 1, open_questions_count: 0 },
+    { id: 'feat_002', type: 'feature', name: 'Feature B', status: 'draft', completeness: 0.3, open_questions_count: 1 },
+    { id: 'comp_001', type: 'component', name: 'Component A', status: 'defined', completeness: 1, open_questions_count: 0 },
+    { id: 'dec_001', type: 'decision', name: 'Decision A', status: 'defined', completeness: 1, open_questions_count: 0 },
+    { id: 'tech_001', type: 'tech_choice', name: 'Tech Choice A', status: 'defined', completeness: 1, open_questions_count: 0 },
+    { id: 'data_001', type: 'data_entity', name: 'Data Entity A', status: 'defined', completeness: 1, open_questions_count: 0 },
+  ],
+  edges: [
+    { from: 'feat_001', to: 'comp_001', relation: 'contains' },
+    { from: 'feat_002', to: 'dec_001', relation: 'depends_on' },
+    { from: 'feat_001', to: 'dec_001', relation: 'governed_by' },
+    { from: 'comp_001', to: 'tech_001', relation: 'implemented_with' },
+    { from: 'dec_001', to: 'data_001', relation: 'reads_writes' },
+  ],
+});
+
+describe('Node Type Toggle Filters', () => {
+
+  describe('all toggles on (default)', () => {
+    it('returns all nodes when no types are hidden', () => {
+      const renderer = createRenderer();
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+      assert.equal(nodes.length, 6);
+    });
+
+    it('returns all edges when no types are hidden', () => {
+      const renderer = createRenderer();
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+      const links = renderer.buildLinks(graphData, nodes);
+      assert.equal(links.length, 5);
+    });
+  });
+
+  describe('hiding a single type', () => {
+    it('hides all nodes of the toggled-off type', () => {
+      const renderer = createRenderer(new Set(['feature']));
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+
+      assert.equal(nodes.length, 4);
+      const hasFeature = nodes.some(n => n.type === 'feature');
+      assert.equal(hasFeature, false, 'No feature nodes should remain');
+    });
+
+    it('hides edges connected to hidden nodes', () => {
+      const renderer = createRenderer(new Set(['feature']));
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+      const links = renderer.buildLinks(graphData, nodes);
+
+      // feat_001->comp_001, feat_002->dec_001, feat_001->dec_001 should all be removed
+      // Only comp_001->tech_001 and dec_001->data_001 remain
+      assert.equal(links.length, 2);
+      const sources = links.map(l => l.source).sort();
+      assert.deepEqual(sources, ['comp_001', 'dec_001']);
+    });
+
+    it('hides decision type nodes and their edges', () => {
+      const renderer = createRenderer(new Set(['decision']));
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+      const links = renderer.buildLinks(graphData, nodes);
+
+      const hasDecision = nodes.some(n => n.type === 'decision');
+      assert.equal(hasDecision, false);
+
+      // Edges referencing dec_001 should be gone
+      const hasDecisionEdge = links.some(l => l.source === 'dec_001' || l.target === 'dec_001');
+      assert.equal(hasDecisionEdge, false);
+    });
+  });
+
+  describe('hiding multiple types', () => {
+    it('hides nodes of all toggled-off types', () => {
+      const renderer = createRenderer(new Set(['feature', 'component']));
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+
+      assert.equal(nodes.length, 3);
+      const types = new Set(nodes.map(n => n.type));
+      assert.equal(types.has('feature'), false);
+      assert.equal(types.has('component'), false);
+      assert.equal(types.has('decision'), true);
+      assert.equal(types.has('tech_choice'), true);
+      assert.equal(types.has('data_entity'), true);
+    });
+
+    it('only keeps edges between remaining visible nodes', () => {
+      const renderer = createRenderer(new Set(['feature', 'component']));
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+      const links = renderer.buildLinks(graphData, nodes);
+
+      // Only dec_001->data_001 should remain
+      assert.equal(links.length, 1);
+      assert.equal(links[0].source, 'dec_001');
+      assert.equal(links[0].target, 'data_001');
+    });
+  });
+
+  describe('hiding all types', () => {
+    it('returns no nodes when all types are hidden', () => {
+      const allTypes = new Set(['feature', 'component', 'decision', 'tech_choice', 'data_entity']);
+      const renderer = createRenderer(allTypes);
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+      assert.equal(nodes.length, 0);
+    });
+
+    it('returns no edges when all types are hidden', () => {
+      const allTypes = new Set(['feature', 'component', 'decision', 'tech_choice', 'data_entity']);
+      const renderer = createRenderer(allTypes);
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+      const links = renderer.buildLinks(graphData, nodes);
+      assert.equal(links.length, 0);
+    });
+  });
+
+  describe('setHiddenTypes method', () => {
+    it('updates the hidden types set', () => {
+      const renderer = createRenderer();
+      renderer.setHiddenTypes(new Set(['feature']));
+      assert.equal(renderer.hiddenTypes.has('feature'), true);
+      assert.equal(renderer.hiddenTypes.size, 1);
+    });
+
+    it('creates a defensive copy of the input set', () => {
+      const renderer = createRenderer();
+      const input = new Set(['feature']);
+      renderer.setHiddenTypes(input);
+      input.add('component');
+      assert.equal(renderer.hiddenTypes.has('component'), false);
+    });
+
+    it('changing hidden types changes buildNodes output', () => {
+      const renderer = createRenderer();
+      const graphData = makeGraphData();
+
+      const nodesBefore = renderer.buildNodes(graphData);
+      assert.equal(nodesBefore.length, 6);
+
+      renderer.setHiddenTypes(new Set(['feature']));
+      const nodesAfter = renderer.buildNodes(graphData);
+      assert.equal(nodesAfter.length, 4);
+    });
+  });
+
+  describe('interaction with hideDefinedActive filter', () => {
+    it('both filters can be active simultaneously', () => {
+      const renderer = createRenderer(new Set(['tech_choice']));
+      renderer.hideDefinedActive = true;
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+
+      // hideDefinedActive removes: feat_001, comp_001, dec_001, data_001 (all defined, completeness=1)
+      // hiddenTypes removes: tech_001 (tech_choice)
+      // Remaining: feat_002 only
+      assert.equal(nodes.length, 1);
+      assert.equal(nodes[0].id, 'feat_002');
+    });
+  });
+
+  describe('edge count preservation', () => {
+    it('calculates edge counts from full graph before filtering', () => {
+      const renderer = createRenderer(new Set(['component']));
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+
+      // feat_001 has 2 edges in the full graph (feat_001->comp_001, feat_001->dec_001)
+      const feat001 = nodes.find(n => n.id === 'feat_001');
+      assert.equal(feat001.edgeCount, 2);
+    });
+  });
+});
+
+describe('GraphLegend type toggle state', () => {
+  // Test the hiddenTypes tracking logic in isolation
+  const createLegendState = () => ({
+    hiddenTypes: new Set(),
+    toggle: function (type) {
+      if (this.hiddenTypes.has(type)) {
+        this.hiddenTypes.delete(type);
+      } else {
+        this.hiddenTypes.add(type);
+      }
+    },
+  });
+
+  it('starts with no hidden types (all on)', () => {
+    const legend = createLegendState();
+    assert.equal(legend.hiddenTypes.size, 0);
+  });
+
+  it('toggling a type adds it to hidden set', () => {
+    const legend = createLegendState();
+    legend.toggle('feature');
+    assert.equal(legend.hiddenTypes.has('feature'), true);
+  });
+
+  it('toggling a type twice removes it from hidden set', () => {
+    const legend = createLegendState();
+    legend.toggle('feature');
+    legend.toggle('feature');
+    assert.equal(legend.hiddenTypes.has('feature'), false);
+  });
+
+  it('can hide multiple types independently', () => {
+    const legend = createLegendState();
+    legend.toggle('feature');
+    legend.toggle('decision');
+    assert.equal(legend.hiddenTypes.size, 2);
+    assert.equal(legend.hiddenTypes.has('feature'), true);
+    assert.equal(legend.hiddenTypes.has('decision'), true);
+  });
+
+  it('toggling one type does not affect others', () => {
+    const legend = createLegendState();
+    legend.toggle('feature');
+    legend.toggle('decision');
+    legend.toggle('feature'); // re-enable feature
+    assert.equal(legend.hiddenTypes.has('feature'), false);
+    assert.equal(legend.hiddenTypes.has('decision'), true);
+  });
+});

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

@@ -0,0 +1,103 @@
+/**
+ * Tests for Node Type Visual Encoding (feat_015).
+ * Uses node:test built-in runner.
+ * Tests shape mapping completeness, path generation, and consistency.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { NODE_COLORS, TYPE_LABELS, NODE_SHAPES, nodeShapePath } from '../packages/frontend/src/constants/graph.js';
+
+describe('Node Type Visual Encoding', () => {
+
+  describe('NODE_SHAPES completeness', () => {
+    it('should have a shape for every node type in NODE_COLORS', () => {
+      for (const type of Object.keys(NODE_COLORS)) {
+        assert.ok(NODE_SHAPES[type], `NODE_SHAPES should have shape for ${type}`);
+      }
+    });
+
+    it('should have exactly the same types as NODE_COLORS', () => {
+      assert.equal(
+        Object.keys(NODE_SHAPES).length,
+        Object.keys(NODE_COLORS).length,
+        'NODE_SHAPES and NODE_COLORS should have the same number of entries'
+      );
+    });
+
+    it('should have a shape for every node type in TYPE_LABELS', () => {
+      for (const type of Object.keys(TYPE_LABELS)) {
+        assert.ok(NODE_SHAPES[type], `NODE_SHAPES should have shape for ${type}`);
+      }
+    });
+  });
+
+  describe('NODE_SHAPES uniqueness', () => {
+    it('should assign unique shapes to each node type', () => {
+      const shapes = Object.values(NODE_SHAPES);
+      const uniqueShapes = new Set(shapes);
+      assert.equal(
+        uniqueShapes.size,
+        shapes.length,
+        `All ${shapes.length} node types should have unique shapes, but only ${uniqueShapes.size} are unique`
+      );
+    });
+  });
+
+  describe('nodeShapePath', () => {
+    it('should return a valid SVG path string for every defined shape', () => {
+      const allShapes = new Set(Object.values(NODE_SHAPES));
+      for (const shape of allShapes) {
+        const path = nodeShapePath(shape, 10);
+        assert.ok(typeof path === 'string', `Path for ${shape} should be a string`);
+        assert.ok(path.length > 0, `Path for ${shape} should not be empty`);
+        assert.ok(path.startsWith('M'), `Path for ${shape} should start with M command`);
+        assert.ok(path.includes('Z'), `Path for ${shape} should be closed (contain Z)`);
+      }
+    });
+
+    it('should return a path for unknown shapes (fallback to circle)', () => {
+      const path = nodeShapePath('unknown_shape', 10);
+      assert.ok(typeof path === 'string');
+      assert.ok(path.startsWith('M'));
+    });
+
+    it('should scale paths based on radius parameter', () => {
+      const smallPath = nodeShapePath('square', 5);
+      const largePath = nodeShapePath('square', 20);
+      assert.notEqual(smallPath, largePath, 'Different radii should produce different paths');
+    });
+
+    it('should handle radius of 0 without error', () => {
+      const allShapes = new Set(Object.values(NODE_SHAPES));
+      for (const shape of allShapes) {
+        assert.doesNotThrow(() => nodeShapePath(shape, 0), `Shape ${shape} should not throw with radius 0`);
+      }
+    });
+
+    it('should produce centered paths (contain negative coordinates)', () => {
+      // All shapes should be centered at (0,0), so they should have negative values
+      const shapesWithNeg = ['square', 'diamond', 'hexagon', 'circle', 'pentagon', 'star', 'octagon'];
+      for (const shape of shapesWithNeg) {
+        const path = nodeShapePath(shape, 10);
+        assert.ok(path.includes('-'), `Path for ${shape} should contain negative coordinates (centered at 0,0)`);
+      }
+    });
+  });
+
+  describe('shape-color-label consistency', () => {
+    it('every node type should have a color, shape, and label', () => {
+      const allTypes = [
+        'feature', 'component', 'data_entity', 'decision', 'tech_choice',
+        'non_functional_requirement', 'design_token', 'design_pattern',
+        'user_role', 'flow', 'assumption', 'open_question',
+      ];
+
+      for (const type of allTypes) {
+        assert.ok(NODE_COLORS[type], `${type} should have a color`);
+        assert.ok(NODE_SHAPES[type], `${type} should have a shape`);
+        assert.ok(TYPE_LABELS[type], `${type} should have a label`);
+      }
+    });
+  });
+});

package/templates/product-system/tests/pipeline-state-store.test.ts

@@ -0,0 +1,268 @@
+/**
+ * Unit tests for pipeline state persistence logic (feat_054).
+ * Tests data transformation and serialization without requiring Drizzle/Turso.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+describe('pipeline-state-store data transformations', () => {
+  it('save serializes tasks and toolCalls to JSON', () => {
+    const state = {
+      status: 'developing',
+      cycle: 1,
+      tasks: {
+        completed: 2,
+        total: 5,
+        items: [
+          { name: 'Task A', status: 'completed' },
+          { name: 'Task B', status: 'completed' },
+          { name: 'Task C', status: 'in_progress' },
+          { name: 'Task D', status: 'pending' },
+          { name: 'Task E', status: 'pending' },
+        ],
+      },
+      toolCalls: { total: 10, write: 2, edit: 3, read: 4, bash: 1 },
+      error: null,
+    };
+
+    const tasksJson = state.tasks ? JSON.stringify(state.tasks.items || []) : null;
+    const toolCallsJson = state.toolCalls ? JSON.stringify(state.toolCalls) : null;
+
+    assert.equal(JSON.parse(tasksJson).length, 5);
+    assert.equal(JSON.parse(toolCallsJson).total, 10);
+  });
+
+  it('load deserializes tasks and computes completed count', () => {
+    const tasksJson = JSON.stringify([
+      { name: 'Task A', status: 'completed' },
+      { name: 'Task B', status: 'completed' },
+      { name: 'Task C', status: 'in_progress' },
+    ]);
+
+    const tasks = JSON.parse(tasksJson);
+    const result = {
+      completed: tasks.filter(t => t.status === 'completed').length,
+      total: tasks.length,
+      items: tasks,
+    };
+
+    assert.equal(result.completed, 2);
+    assert.equal(result.total, 3);
+    assert.equal(result.items.length, 3);
+  });
+
+  it('load returns undefined tasks when tasksJson is null', () => {
+    const tasksJson = null;
+    const tasks = tasksJson ? JSON.parse(tasksJson) : [];
+    const result = tasks.length > 0 ? {
+      completed: tasks.filter(t => t.status === 'completed').length,
+      total: tasks.length,
+      items: tasks,
+    } : undefined;
+
+    assert.equal(result, undefined);
+  });
+
+  it('load returns undefined toolCalls when toolCallsJson is null', () => {
+    const toolCallsJson = null;
+    const toolCalls = toolCallsJson ? JSON.parse(toolCallsJson) : null;
+    const result = toolCalls && toolCalls.total > 0 ? toolCalls : undefined;
+
+    assert.equal(result, undefined);
+  });
+
+  it('load returns undefined toolCalls when total is 0', () => {
+    const toolCallsJson = JSON.stringify({ total: 0, write: 0, edit: 0, read: 0, bash: 0 });
+    const toolCalls = JSON.parse(toolCallsJson);
+    const result = toolCalls && toolCalls.total > 0 ? toolCalls : undefined;
+
+    assert.equal(result, undefined);
+  });
+
+  it('save handles null tasks gracefully', () => {
+    const state = {
+      status: 'completed',
+      cycle: 2,
+      tasks: null,
+      toolCalls: null,
+      error: null,
+    };
+
+    const tasksJson = state.tasks ? JSON.stringify(state.tasks.items || []) : null;
+    const toolCallsJson = state.toolCalls ? JSON.stringify(state.toolCalls) : null;
+
+    assert.equal(tasksJson, null);
+    assert.equal(toolCallsJson, null);
+  });
+
+  it('save includes error when present', () => {
+    const state = {
+      status: 'failed',
+      cycle: 1,
+      error: 'Developer failed: process exited with code 1',
+    };
+
+    const row = {
+      featureId: 'feat_010',
+      status: state.status,
+      cycle: state.cycle || 1,
+      tasksJson: null,
+      toolCallsJson: null,
+      error: state.error || null,
+      updatedAt: new Date().toISOString(),
+    };
+
+    assert.equal(row.error, 'Developer failed: process exited with code 1');
+    assert.equal(row.status, 'failed');
+  });
+});
+
+describe('pipeline-state-store markInterrupted logic', () => {
+  it('identifies active statuses correctly', () => {
+    const activeStatuses = ['developing', 'reviewing', 'fixing_review', 'fixing_merge', 'merging', 'debugging', 'creating_worktree'];
+    const terminalStatuses = ['completed', 'failed', 'blocked', 'interrupted', 'idle'];
+
+    for (const status of activeStatuses) {
+      assert.ok(activeStatuses.includes(status), `${status} should be active`);
+    }
+    for (const status of terminalStatuses) {
+      assert.ok(!activeStatuses.includes(status), `${status} should not be active`);
+    }
+  });
+
+  it('markInterrupted transforms active rows to interrupted', () => {
+    const rows = [
+      { featureId: 'feat_001', status: 'developing' },
+      { featureId: 'feat_002', status: 'completed' },
+      { featureId: 'feat_003', status: 'reviewing' },
+      { featureId: 'feat_004', status: 'failed' },
+      { featureId: 'feat_005', status: 'merging' },
+    ];
+
+    const activeStatuses = ['developing', 'reviewing', 'fixing_review', 'fixing_merge', 'merging', 'debugging', 'creating_worktree'];
+    const toInterrupt = rows.filter(r => activeStatuses.includes(r.status));
+
+    assert.equal(toInterrupt.length, 3);
+    assert.deepEqual(toInterrupt.map(r => r.featureId), ['feat_001', 'feat_003', 'feat_005']);
+  });
+});
+
+describe('pipeline getStatus with DB fallback', () => {
+  it('returns DB state when in-memory state is absent', () => {
+    const dbState = {
+      status: 'interrupted',
+      cycle: 2,
+      feature_id: 'feat_010',
+      error: null,
+      tasks: {
+        completed: 3,
+        total: 5,
+        items: [
+          { name: 'Task A', status: 'completed' },
+          { name: 'Task B', status: 'completed' },
+          { name: 'Task C', status: 'completed' },
+          { name: 'Task D', status: 'in_progress' },
+          { name: 'Task E', status: 'pending' },
+        ],
+      },
+      toolCalls: { total: 15, write: 3, edit: 5, read: 5, bash: 2 },
+    };
+
+    const pipelines = new Map();
+    const state = pipelines.get('feat_010');
+    assert.equal(state, undefined);
+
+    // Simulates the fallback
+    const result = state ? state : dbState || { status: 'idle', feature_id: 'feat_010' };
+    assert.equal(result.status, 'interrupted');
+    assert.equal(result.tasks.completed, 3);
+    assert.equal(result.toolCalls.total, 15);
+  });
+
+  it('returns idle when neither in-memory nor DB has state', () => {
+    const pipelines = new Map();
+    const state = pipelines.get('feat_999');
+    const dbState = null;
+
+    const result = state ? state : dbState || { status: 'idle', feature_id: 'feat_999' };
+    assert.equal(result.status, 'idle');
+  });
+
+  it('prefers in-memory state over DB state', () => {
+    const pipelines = new Map();
+    pipelines.set('feat_010', {
+      status: 'developing',
+      cycle: 1,
+      tasks: { completed: 1, total: 3, items: [] },
+    });
+
+    const state = pipelines.get('feat_010');
+    assert.equal(state.status, 'developing');
+  });
+});
+
+describe('pipeline persistState integration with pipeline.js', () => {
+  it('persistState is called at each status transition', async () => {
+    const persistCalls = [];
+    const mockStateStore = {
+      save: async (featureId, state) => {
+        persistCalls.push({ featureId, status: state.status });
+      },
+    };
+
+    // Simulate the persistState helper from pipeline.js
+    const pipelines = new Map();
+    const persistState = (featureId) => {
+      if (!mockStateStore) return;
+      const state = pipelines.get(featureId);
+      if (!state) return;
+      mockStateStore.save(featureId, state);
+    };
+
+    pipelines.set('feat_010', { status: 'developing', cycle: 1 });
+    persistState('feat_010');
+
+    pipelines.get('feat_010').status = 'reviewing';
+    persistState('feat_010');
+
+    pipelines.get('feat_010').status = 'completed';
+    persistState('feat_010');
+
+    // Wait for async operations
+    await new Promise(r => setTimeout(r, 10));
+
+    assert.equal(persistCalls.length, 3);
+    assert.equal(persistCalls[0].status, 'developing');
+    assert.equal(persistCalls[1].status, 'reviewing');
+    assert.equal(persistCalls[2].status, 'completed');
+  });
+
+  it('persistState handles stateStore failure gracefully', async () => {
+    const errors = [];
+    const mockStateStore = {
+      save: async () => {
+        throw new Error('DB connection lost');
+      },
+    };
+
+    const pipelines = new Map();
+    const log = (tag, msg) => { if (tag === 'PERSIST') errors.push(msg); };
+
+    const persistState = (featureId) => {
+      if (!mockStateStore) return;
+      const state = pipelines.get(featureId);
+      if (!state) return;
+      mockStateStore.save(featureId, state).catch(err => {
+        log('PERSIST', `Failed to persist state for ${featureId}: ${err.message}`);
+      });
+    };
+
+    pipelines.set('feat_010', { status: 'developing', cycle: 1 });
+    persistState('feat_010');
+
+    await new Promise(r => setTimeout(r, 10));
+
+    assert.equal(errors.length, 1);
+    assert.ok(errors[0].includes('DB connection lost'));
+  });
+});