@assistkick/create 1.0.0

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

@@ -0,0 +1,195 @@
+/**
+ * Tests for the automated development pipeline logic.
+ * Tests pipeline state management, prompt building, and debug-first logic.
+ * Uses node:test built-in runner.
+ *
+ * Note: Integration tests that depended on kanban.json have been removed
+ * (kanban moved to Turso). See pipeline-unit.test.js for unit tests with
+ * mocked dependencies.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SKILL_DIR = join(__dirname, '..');
+
+describe('Pipeline state transitions', () => {
+  it('pipeline statuses include all expected values', () => {
+    const expectedStatuses = [
+      'creating_worktree', 'debugging', 'developing', 'reviewing',
+      'fixing_review', 'merging', 'completed', 'failed', 'blocked',
+    ];
+    // Just verify we documented the expected statuses
+    assert.ok(expectedStatuses.length === 9);
+  });
+});
+
+describe('Worktree command formation', () => {
+  it('worktree path follows expected pattern', () => {
+    const featureId = 'feat_010';
+    const worktreesDir = join(SKILL_DIR, '..', '.worktrees');
+    const expectedPath = join(worktreesDir, featureId);
+    const expectedBranch = `feature/${featureId}`;
+
+    assert.ok(expectedPath.includes('.worktrees/feat_010'));
+    assert.equal(expectedBranch, 'feature/feat_010');
+  });
+
+  it('worktree command args are correctly formed', () => {
+    const featureId = 'feat_015';
+    const worktreePath = join(SKILL_DIR, '..', '.worktrees', featureId);
+    const args = ['worktree', 'add', worktreePath, '-b', `feature/${featureId}`];
+
+    assert.equal(args[0], 'worktree');
+    assert.equal(args[1], 'add');
+    assert.ok(args[2].endsWith('feat_015'));
+    assert.equal(args[3], '-b');
+    assert.equal(args[4], 'feature/feat_015');
+  });
+});
+
+describe('Prompt interpolation', () => {
+  it('developer prompt includes feature ID', async () => {
+    const { readFile } = await import('node:fs/promises');
+    const skillPath = join(SKILL_DIR, '..', '.claude', 'skills', 'product-developer', 'SKILL.md');
+    let skillContent = '';
+    try {
+      skillContent = await readFile(skillPath, 'utf-8');
+    } catch { /* skill file may not exist in test env */ }
+
+    const featureId = 'feat_012';
+    const cycle = 1;
+    // Simulate prompt building
+    let prompt = skillContent + '\n\n## Current Task\n';
+    prompt += `Implement feature ${featureId}.`;
+
+    assert.ok(prompt.includes('feat_012'));
+    assert.ok(prompt.includes('## Current Task'));
+  });
+
+  it('developer prompt includes review notes on retry cycles', () => {
+    const featureId = 'feat_012';
+    const cycle = 2;
+    const previousNotes = 'Missing unit tests for edge cases';
+
+    let prompt = `## Current Task\nImplement feature ${featureId}.\n`;
+    prompt += `\n## Previous Review Feedback (Cycle ${cycle})\n`;
+    prompt += `The previous implementation was rejected. Fix the following issues:\n`;
+    prompt += previousNotes + '\n';
+
+    assert.ok(prompt.includes('Cycle 2'));
+    assert.ok(prompt.includes('Missing unit tests'));
+    assert.ok(prompt.includes('feat_012'));
+  });
+
+  it('reviewer prompt includes feature ID', async () => {
+    const featureId = 'feat_014';
+    let prompt = `## Current Task\nReview feature ${featureId}.`;
+
+    assert.ok(prompt.includes('feat_014'));
+    assert.ok(prompt.includes('Review feature'));
+  });
+
+  it('developer prompt includes debugger findings when provided', () => {
+    const featureId = 'feat_012';
+    const debuggerFindings = 'Root cause: missing null check in graph_renderer.js line 42';
+
+    let prompt = `## Current Task\nImplement feature ${featureId}.\n`;
+    prompt += `\n## Debugger Investigation Findings\n`;
+    prompt += `A debugger agent has investigated the QA rejection notes and identified root causes.\n`;
+    prompt += `Use these findings to fix the actual root causes rather than just the symptom descriptions:\n\n`;
+    prompt += debuggerFindings + '\n';
+
+    assert.ok(prompt.includes('Debugger Investigation Findings'));
+    assert.ok(prompt.includes('Root cause: missing null check'));
+    assert.ok(prompt.includes('feat_012'));
+  });
+
+  it('developer prompt omits debugger findings when not provided', () => {
+    const featureId = 'feat_012';
+
+    let prompt = `## Current Task\nImplement feature ${featureId}.\n`;
+
+    assert.ok(prompt.includes('feat_012'));
+    assert.ok(!prompt.includes('Debugger Investigation Findings'));
+  });
+});
+
+describe('Debug-first pipeline logic', () => {
+  it('identifies unaddressed QA notes correctly', () => {
+    const notes = [
+      { id: 'n1', text: 'Bug: missing validation', addressed: false },
+      { id: 'n2', text: 'Bug: wrong color', addressed: true },
+      { id: 'n3', text: 'Bug: crash on empty input' },
+    ];
+
+    const unaddressed = notes.filter(n => !n.addressed);
+    assert.equal(unaddressed.length, 2);
+    assert.equal(unaddressed[0].id, 'n1');
+    assert.equal(unaddressed[1].id, 'n3');
+  });
+
+  it('marks notes as addressed after processing', () => {
+    const notes = [
+      { id: 'n1', text: 'Bug: missing validation', addressed: false },
+      { id: 'n2', text: 'Bug: wrong color' },
+    ];
+
+    for (const note of notes) {
+      if (!note.addressed) {
+        note.addressed = true;
+      }
+    }
+
+    assert.equal(notes[0].addressed, true);
+    assert.equal(notes[1].addressed, true);
+  });
+
+  it('skips debugging when all notes are already addressed', () => {
+    const notes = [
+      { id: 'n1', text: 'Bug: fixed', addressed: true },
+      { id: 'n2', text: 'Bug: also fixed', addressed: true },
+    ];
+
+    const unaddressed = notes.filter(n => !n.addressed);
+    assert.equal(unaddressed.length, 0);
+  });
+
+  it('skips debugging when there are no notes', () => {
+    const notes = [];
+    const unaddressed = notes.filter(n => !n.addressed);
+    assert.equal(unaddressed.length, 0);
+  });
+});
+
+describe('Debugger prompt construction', () => {
+  it('debugger prompt includes QA notes', () => {
+    const featureId = 'feat_015';
+    const notes = [
+      { id: 'n1', text: 'Breaks feat_012 neighborhood focus mode' },
+      { id: 'n2', text: 'Missing unit tests for edge cases' },
+    ];
+
+    let prompt = `## Current Task\n`;
+    prompt += `Feature: ${featureId}\n\n`;
+    prompt += `## QA Rejection Notes to Investigate\n`;
+    for (const note of notes) {
+      prompt += `- [${note.id}] ${note.text}\n`;
+    }
+
+    assert.ok(prompt.includes('feat_015'));
+    assert.ok(prompt.includes('[n1] Breaks feat_012'));
+    assert.ok(prompt.includes('[n2] Missing unit tests'));
+    assert.ok(prompt.includes('QA Rejection Notes to Investigate'));
+  });
+
+  it('debugger prompt instructs not to create bugfix features', () => {
+    let prompt = `## Instructions\n`;
+    prompt += `Do NOT create bugfix features, do NOT move kanban cards, do NOT write code fixes\n`;
+
+    assert.ok(prompt.includes('Do NOT create bugfix features'));
+    assert.ok(prompt.includes('do NOT move kanban cards'));
+  });
+});

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

@@ -0,0 +1,193 @@
+/**
+ * Tests for feat_055: Show Pipeline Stats on All Kanban Cards.
+ * Verifies that persisted pipeline stats are fetched for cards in ALL columns,
+ * not just active ones.
+ * Uses node:test built-in runner.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+/**
+ * The core logic change in feat_055 is removing the column guard from buildCard
+ * so that getPipelineStatus is called for every card regardless of column.
+ *
+ * Since kanban_renderer.js is a browser-side class (creates DOM elements),
+ * we test the data-level behavior: given a pipeline status response,
+ * the update functions should produce correct display data for any column.
+ */
+
+// --- Logic extracted from updateTaskProgress ---
+const formatTaskProgress = (tasks) => {
+  if (!tasks || tasks.total === 0) return null;
+  return `${tasks.completed}/${tasks.total} tasks`;
+};
+
+// --- Logic extracted from updateToolCalls ---
+const formatToolCalls = (toolCalls) => {
+  if (!toolCalls || toolCalls.total === 0) return null;
+  const items = [
+    { label: 'Write', count: toolCalls.write },
+    { label: 'Edit', count: toolCalls.edit },
+    { label: 'Read', count: toolCalls.read },
+    { label: 'Bash', count: toolCalls.bash },
+  ];
+  return items
+    .filter(item => item.count > 0)
+    .map(item => `${item.label}: ${item.count}`);
+};
+
+// --- Logic for determining if polling should start ---
+const TERMINAL_STATUSES = ['completed', 'failed', 'blocked', 'interrupted'];
+
+const shouldStartPolling = (status) => {
+  if (status === 'idle') return false;
+  return !TERMINAL_STATUSES.includes(status);
+};
+
+const shouldShowStats = (status) => {
+  return status !== 'idle';
+};
+
+describe('Pipeline stats on all kanban cards', () => {
+  describe('formatTaskProgress', () => {
+    it('returns formatted string when tasks have total > 0', () => {
+      assert.equal(formatTaskProgress({ completed: 3, total: 7, items: [] }), '3/7 tasks');
+    });
+
+    it('returns null when tasks total is 0', () => {
+      assert.equal(formatTaskProgress({ completed: 0, total: 0, items: [] }), null);
+    });
+
+    it('returns null when tasks is undefined', () => {
+      assert.equal(formatTaskProgress(undefined), null);
+    });
+
+    it('returns null when tasks is null', () => {
+      assert.equal(formatTaskProgress(null), null);
+    });
+
+    it('handles fully completed tasks', () => {
+      assert.equal(formatTaskProgress({ completed: 7, total: 7, items: [] }), '7/7 tasks');
+    });
+  });
+
+  describe('formatToolCalls', () => {
+    it('returns badges for non-zero counts', () => {
+      const result = formatToolCalls({ total: 28, write: 5, edit: 3, read: 12, bash: 8 });
+      assert.deepEqual(result, ['Write: 5', 'Edit: 3', 'Read: 12', 'Bash: 8']);
+    });
+
+    it('omits zero-count tools', () => {
+      const result = formatToolCalls({ total: 17, write: 5, edit: 0, read: 12, bash: 0 });
+      assert.deepEqual(result, ['Write: 5', 'Read: 12']);
+    });
+
+    it('returns null when total is 0', () => {
+      assert.equal(formatToolCalls({ total: 0, write: 0, edit: 0, read: 0, bash: 0 }), null);
+    });
+
+    it('returns null when toolCalls is undefined', () => {
+      assert.equal(formatToolCalls(undefined), null);
+    });
+
+    it('returns null when toolCalls is null', () => {
+      assert.equal(formatToolCalls(null), null);
+    });
+  });
+
+  describe('shouldShowStats — stats visibility for all columns', () => {
+    const columns = ['todo', 'in_progress', 'in_review', 'qa', 'done'];
+
+    for (const column of columns) {
+      it(`shows stats for ${column} card with completed pipeline`, () => {
+        // A card that has been through the pipeline has status 'completed'
+        assert.equal(shouldShowStats('completed'), true,
+          `${column} card with completed status should show stats`);
+      });
+
+      it(`hides stats for ${column} card with no pipeline history (idle)`, () => {
+        assert.equal(shouldShowStats('idle'), false,
+          `${column} card with idle status should not show stats`);
+      });
+    }
+
+    it('shows stats for active pipeline statuses', () => {
+      const activeStatuses = ['developing', 'reviewing', 'merging', 'debugging', 'fixing_review'];
+      for (const status of activeStatuses) {
+        assert.equal(shouldShowStats(status), true, `${status} should show stats`);
+      }
+    });
+
+    it('shows stats for terminal pipeline statuses', () => {
+      for (const status of TERMINAL_STATUSES) {
+        assert.equal(shouldShowStats(status), true, `${status} should show stats`);
+      }
+    });
+  });
+
+  describe('shouldStartPolling — only for active pipelines', () => {
+    it('does not poll for idle status', () => {
+      assert.equal(shouldStartPolling('idle'), false);
+    });
+
+    it('does not poll for completed status', () => {
+      assert.equal(shouldStartPolling('completed'), false);
+    });
+
+    it('does not poll for failed status', () => {
+      assert.equal(shouldStartPolling('failed'), false);
+    });
+
+    it('does not poll for blocked status', () => {
+      assert.equal(shouldStartPolling('blocked'), false);
+    });
+
+    it('does not poll for interrupted status', () => {
+      assert.equal(shouldStartPolling('interrupted'), false);
+    });
+
+    it('polls for developing status', () => {
+      assert.equal(shouldStartPolling('developing'), true);
+    });
+
+    it('polls for reviewing status', () => {
+      assert.equal(shouldStartPolling('reviewing'), true);
+    });
+
+    it('polls for merging status', () => {
+      assert.equal(shouldStartPolling('merging'), true);
+    });
+  });
+
+  describe('end-to-end scenario: Done column card shows final stats', () => {
+    it('a done card with persisted pipeline data shows task progress and tool calls', () => {
+      // Simulate what GET /api/kanban/:id/pipeline returns for a completed feature
+      const pipelineResponse = {
+        status: 'completed',
+        cycle: 1,
+        feature_id: 'feat_042',
+        tasks: { completed: 7, total: 7, items: [] },
+        toolCalls: { total: 28, write: 5, edit: 3, read: 12, bash: 8 },
+      };
+
+      // The card is in Done column — previously this was excluded from stats fetch
+      const column = 'done';
+
+      // feat_055: stats should be visible regardless of column
+      assert.equal(shouldShowStats(pipelineResponse.status), true);
+      assert.equal(formatTaskProgress(pipelineResponse.tasks), '7/7 tasks');
+      assert.deepEqual(formatToolCalls(pipelineResponse.toolCalls), ['Write: 5', 'Edit: 3', 'Read: 12', 'Bash: 8']);
+
+      // Should NOT start polling for completed pipeline
+      assert.equal(shouldStartPolling(pipelineResponse.status), false);
+    });
+
+    it('a todo card with no pipeline history shows nothing', () => {
+      const pipelineResponse = { status: 'idle' };
+
+      assert.equal(shouldShowStats(pipelineResponse.status), false);
+      assert.equal(formatTaskProgress(pipelineResponse.tasks), null);
+      assert.equal(formatToolCalls(pipelineResponse.toolCalls), null);
+    });
+  });
+});

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

@@ -0,0 +1,296 @@
+/**
+ * Tests for Play All button logic — dependency checking and sequential processing.
+ * Uses node:test built-in runner.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+/**
+ * Extracted dependency-checking logic matching KanbanRenderer.checkDependencies.
+ * Tests the pure data transformation without DOM dependencies.
+ */
+const checkDependencies = (featureId, graphData, kanbanData) => {
+  if (!graphData || !kanbanData) return { blocked: false, blockedBy: [] };
+
+  const deps = graphData.edges
+    .filter(e => e.from === featureId && e.relation === 'depends_on')
+    .map(e => e.to)
+    .filter(depId => graphData.nodes.some(n => n.id === depId && n.type === 'feature'));
+
+  const blockedBy = deps.filter(depId => {
+    const entry = kanbanData[depId];
+    return !entry || entry.column !== 'done';
+  });
+
+  return { blocked: blockedBy.length > 0, blockedBy };
+};
+
+/**
+ * Simulates the Play All ordering logic: find next processable feature.
+ * Returns the first TODO feature whose dependencies are all in Done, or null.
+ */
+const findNextProcessable = (todoCards, graphData, kanbanData) => {
+  for (const card of todoCards) {
+    if (card.devBlocked) continue;
+    const { blocked } = checkDependencies(card.id, graphData, kanbanData);
+    if (!blocked) return card;
+  }
+  return null;
+};
+
+/**
+ * Detects deadlock: returns true if all TODO features are blocked.
+ */
+const isDeadlocked = (todoCards, graphData, kanbanData) => {
+  const nonBlockedTodo = todoCards.filter(c => !c.devBlocked);
+  if (nonBlockedTodo.length === 0) return false;
+  return findNextProcessable(nonBlockedTodo, graphData, kanbanData) === null;
+};
+
+describe('checkDependencies', () => {
+  it('returns not blocked when feature has no depends_on edges', () => {
+    const graphData = {
+      nodes: [{ id: 'feat_001', type: 'feature' }],
+      edges: [],
+    };
+    const kanbanData = { feat_001: { column: 'todo' } };
+
+    const result = checkDependencies('feat_001', graphData, kanbanData);
+    assert.equal(result.blocked, false);
+    assert.deepEqual(result.blockedBy, []);
+  });
+
+  it('returns not blocked when all dependencies are in done column', () => {
+    const graphData = {
+      nodes: [
+        { id: 'feat_001', type: 'feature' },
+        { id: 'feat_002', type: 'feature' },
+        { id: 'feat_003', type: 'feature' },
+      ],
+      edges: [
+        { from: 'feat_001', to: 'feat_002', relation: 'depends_on' },
+        { from: 'feat_001', to: 'feat_003', relation: 'depends_on' },
+      ],
+    };
+    const kanbanData = {
+      feat_001: { column: 'todo' },
+      feat_002: { column: 'done' },
+      feat_003: { column: 'done' },
+    };
+
+    const result = checkDependencies('feat_001', graphData, kanbanData);
+    assert.equal(result.blocked, false);
+    assert.deepEqual(result.blockedBy, []);
+  });
+
+  it('returns blocked when a dependency is not in done column', () => {
+    const graphData = {
+      nodes: [
+        { id: 'feat_001', type: 'feature' },
+        { id: 'feat_002', type: 'feature' },
+      ],
+      edges: [
+        { from: 'feat_001', to: 'feat_002', relation: 'depends_on' },
+      ],
+    };
+    const kanbanData = {
+      feat_001: { column: 'todo' },
+      feat_002: { column: 'in_progress' },
+    };
+
+    const result = checkDependencies('feat_001', graphData, kanbanData);
+    assert.equal(result.blocked, true);
+    assert.deepEqual(result.blockedBy, ['feat_002']);
+  });
+
+  it('returns blocked when a dependency has no kanban entry', () => {
+    const graphData = {
+      nodes: [
+        { id: 'feat_001', type: 'feature' },
+        { id: 'feat_002', type: 'feature' },
+      ],
+      edges: [
+        { from: 'feat_001', to: 'feat_002', relation: 'depends_on' },
+      ],
+    };
+    const kanbanData = {
+      feat_001: { column: 'todo' },
+    };
+
+    const result = checkDependencies('feat_001', graphData, kanbanData);
+    assert.equal(result.blocked, true);
+    assert.deepEqual(result.blockedBy, ['feat_002']);
+  });
+
+  it('ignores non-feature dependency targets', () => {
+    const graphData = {
+      nodes: [
+        { id: 'feat_001', type: 'feature' },
+        { id: 'comp_001', type: 'component' },
+      ],
+      edges: [
+        { from: 'feat_001', to: 'comp_001', relation: 'depends_on' },
+      ],
+    };
+    const kanbanData = {
+      feat_001: { column: 'todo' },
+    };
+
+    const result = checkDependencies('feat_001', graphData, kanbanData);
+    assert.equal(result.blocked, false);
+    assert.deepEqual(result.blockedBy, []);
+  });
+
+  it('ignores non-depends_on edge types', () => {
+    const graphData = {
+      nodes: [
+        { id: 'feat_001', type: 'feature' },
+        { id: 'feat_002', type: 'feature' },
+      ],
+      edges: [
+        { from: 'feat_001', to: 'feat_002', relation: 'relates_to' },
+      ],
+    };
+    const kanbanData = {
+      feat_001: { column: 'todo' },
+      feat_002: { column: 'todo' },
+    };
+
+    const result = checkDependencies('feat_001', graphData, kanbanData);
+    assert.equal(result.blocked, false);
+  });
+
+  it('returns safe defaults when graphData or kanbanData is null', () => {
+    assert.deepEqual(checkDependencies('feat_001', null, {}), { blocked: false, blockedBy: [] });
+    assert.deepEqual(checkDependencies('feat_001', { edges: [], nodes: [] }, null), { blocked: false, blockedBy: [] });
+  });
+});
+
+describe('findNextProcessable', () => {
+  const graphData = {
+    nodes: [
+      { id: 'feat_001', type: 'feature' },
+      { id: 'feat_002', type: 'feature' },
+      { id: 'feat_003', type: 'feature' },
+    ],
+    edges: [
+      { from: 'feat_002', to: 'feat_001', relation: 'depends_on' },
+    ],
+  };
+
+  it('returns first unblocked feature', () => {
+    const kanbanData = {
+      feat_001: { column: 'todo' },
+      feat_002: { column: 'todo' },
+    };
+    const cards = [
+      { id: 'feat_001', devBlocked: false },
+      { id: 'feat_002', devBlocked: false },
+    ];
+
+    const next = findNextProcessable(cards, graphData, kanbanData);
+    assert.equal(next.id, 'feat_001');
+  });
+
+  it('skips features with unmet dependencies', () => {
+    const kanbanData = {
+      feat_001: { column: 'todo' },
+      feat_002: { column: 'todo' },
+      feat_003: { column: 'todo' },
+    };
+    const cards = [
+      { id: 'feat_002', devBlocked: false }, // depends on feat_001 which is in todo
+      { id: 'feat_001', devBlocked: false }, // no deps
+      { id: 'feat_003', devBlocked: false }, // no deps
+    ];
+
+    const next = findNextProcessable(cards, graphData, kanbanData);
+    assert.equal(next.id, 'feat_001');
+  });
+
+  it('skips devBlocked features', () => {
+    const kanbanData = {
+      feat_001: { column: 'todo' },
+      feat_003: { column: 'todo' },
+    };
+    const cards = [
+      { id: 'feat_001', devBlocked: true },
+      { id: 'feat_003', devBlocked: false },
+    ];
+
+    const next = findNextProcessable(cards, graphData, kanbanData);
+    assert.equal(next.id, 'feat_003');
+  });
+
+  it('returns null when all features are blocked', () => {
+    const kanbanData = {
+      feat_002: { column: 'todo' },
+    };
+    const cards = [
+      { id: 'feat_002', devBlocked: false }, // depends on feat_001 not in done
+    ];
+
+    const next = findNextProcessable(cards, graphData, kanbanData);
+    assert.equal(next, null);
+  });
+});
+
+describe('isDeadlocked', () => {
+  it('returns true when all TODO features have unmet dependencies', () => {
+    const graphData = {
+      nodes: [
+        { id: 'feat_001', type: 'feature' },
+        { id: 'feat_002', type: 'feature' },
+      ],
+      edges: [
+        { from: 'feat_001', to: 'feat_002', relation: 'depends_on' },
+        { from: 'feat_002', to: 'feat_001', relation: 'depends_on' },
+      ],
+    };
+    const kanbanData = {
+      feat_001: { column: 'todo' },
+      feat_002: { column: 'todo' },
+    };
+    const cards = [
+      { id: 'feat_001', devBlocked: false },
+      { id: 'feat_002', devBlocked: false },
+    ];
+
+    assert.equal(isDeadlocked(cards, graphData, kanbanData), true);
+  });
+
+  it('returns false when at least one feature is processable', () => {
+    const graphData = {
+      nodes: [
+        { id: 'feat_001', type: 'feature' },
+        { id: 'feat_002', type: 'feature' },
+      ],
+      edges: [
+        { from: 'feat_002', to: 'feat_001', relation: 'depends_on' },
+      ],
+    };
+    const kanbanData = {
+      feat_001: { column: 'todo' },
+      feat_002: { column: 'todo' },
+    };
+    const cards = [
+      { id: 'feat_001', devBlocked: false },
+      { id: 'feat_002', devBlocked: false },
+    ];
+
+    assert.equal(isDeadlocked(cards, graphData, kanbanData), false);
+  });
+
+  it('returns false when TODO list is empty', () => {
+    const graphData = { nodes: [], edges: [] };
+    assert.equal(isDeadlocked([], graphData, {}), false);
+  });
+
+  it('returns false when all TODO cards are devBlocked', () => {
+    const graphData = { nodes: [{ id: 'feat_001', type: 'feature' }], edges: [] };
+    const kanbanData = { feat_001: { column: 'todo' } };
+    const cards = [{ id: 'feat_001', devBlocked: true }];
+
+    assert.equal(isDeadlocked(cards, graphData, kanbanData), false);
+  });
+});