kanbango 3.5.0 → 3.8.0

package/mcp-server.js

@@ -11,13 +11,25 @@ const plan = require('./plan.js');
 const guiRegistry = require('./gui-registry.js');
 const playbook = require('./agent-playbook.js');
 
-const COLS = kanban.COLS;
 const READ_VIEWS = Object.keys(kanban.VIEW_FIELDS);
 const GUI_READY_TIMEOUT_MS = 8000;
 const GUI_READY_POLL_MS = 50;
 let guiProcess = null;
 let guiPort = null;
 
+function activeCols() {
+  return kanban.COLS.slice();
+}
+
+function transitionHint() {
+  const map = kanban.COLUMN_TRANSITIONS || {};
+  const parts = Object.keys(map).map((from) => {
+    const to = (map[from] || []).join('|');
+    return `${from}→${to || '(none)'}`;
+  });
+  return parts.join('; ') || 'see backlog/kanbango.json columns';
+}
+
 function normalizePort(value) {
   return guiRegistry.normalizeGuiPort(value);
 }
@@ -151,12 +163,23 @@ async function buildEpicLookup() {
 }
 
 async function formatTaskResult(task, returnShape) {
-  if (returnShape === 'none') return { ok: true };
+  if (returnShape === 'none') {
+    if (Array.isArray(task.unblocked_tasks) && task.unblocked_tasks.length > 0) {
+      return { ok: true, unblocked_tasks: task.unblocked_tasks };
+    }
+    return { ok: true };
+  }
   const epicLookup = await buildEpicLookup();
-  return kanban.shapeTask(task, {
+  const allTasks = await kanban.allTasks();
+  const shaped = kanban.shapeTask(task, {
     view: returnShape === 'full' ? 'full' : 'summary',
-    epicLookup
+    epicLookup,
+    allTasks
   });
+  if (Array.isArray(task.unblocked_tasks)) {
+    shaped.unblocked_tasks = task.unblocked_tasks;
+  }
+  return shaped;
 }
 
 function guiIdentity(extra = {}) {
@@ -317,6 +340,8 @@ const server = new Server(
 );
 
 server.setRequestHandler(ListToolsRequestSchema, async () => {
+  await require('./workflow.js').ensureBoardConfig();
+  const COLS = activeCols();
   return {
     tools: [
       {
@@ -327,8 +352,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           properties: {
             operation: {
               type: 'string',
-              enum: ['list', 'show', 'list_epics', 'show_epic', 'help'],
-              description: 'list/show=tasks; list_epics/show_epic=initiative containers; help=token playbook',
+              enum: ['list', 'show', 'list_epics', 'show_epic', 'context', 'help'],
+              description: 'list/show=tasks; context=compact next action; list_epics/show_epic=initiative containers; help=token playbook',
               default: 'list'
             },
             task_id: {
@@ -452,6 +477,16 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
               description: 'Verification scenarios',
               items: { type: 'string' }
             },
+            depends_on: {
+              type: 'array',
+              description: 'Task ids that must be done before this task can enter active/gates',
+              items: { type: 'string' }
+            },
+            files: {
+              type: 'array',
+              description: 'Touched file paths for this task (create/update/plan_evidence)',
+              items: { type: 'string' }
+            },
             subtasks: {
               type: 'array',
               description: 'Full subtask list replace on update (send complete array, not a single toggle)',
@@ -502,7 +537,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             column: {
               type: 'string',
               enum: COLS,
-              description: 'Target column for move (not col)'
+              description:
+                'Target column for move (not col). Must be a legal transition from the current column. '
+                + `Allowed (from project config): ${transitionHint()}. `
+                + 'Illegal → INVALID_TRANSITION + allowed_columns.'
             },
             patch: {
               type: 'object',
@@ -520,31 +558,35 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             steps: {
               type: 'array',
               items: { type: 'string' },
-              description: 'plan_create: implementation steps between red/green test steps'
+              description: 'create/plan_create: checklist texts → subtasks (create uses when subtasks omitted; plan_create uses as-is, no forced TDD steps)'
             },
             project_root: {
               type: 'string',
-              description: 'plan_create: root for test-runner detect (default cwd)'
+              description: 'plan_create: root for optional test-runner detect (default cwd); missing runner → null, not error'
             },
             diff: {
               type: 'string',
-              description: 'plan_evidence: short diff or summary (not whole repo)'
+              description: 'plan_evidence: short diff or note (one of diff/summary/test_command required)'
+            },
+            summary: {
+              type: 'string',
+              description: 'plan_evidence: short implementation summary (alternative to diff)'
             },
             test_command: {
               type: 'string',
-              description: 'plan_evidence: exact command run'
+              description: 'plan_evidence: optional exact command run'
             },
             stdout: {
               type: 'string',
-              description: 'plan_evidence: test stdout (truncate to last ~2KB if huge)'
+              description: 'plan_evidence: optional test stdout (truncate to last ~2KB if huge)'
             },
             stderr: {
               type: 'string',
-              description: 'plan_evidence: test stderr (truncate if huge)'
+              description: 'plan_evidence: optional test stderr (truncate if huge)'
             },
             exit_code: {
               type: 'integer',
-              description: 'plan_evidence: process exit code'
+              description: 'plan_evidence: optional process exit code'
             }
           },
           required: ['action'],
@@ -590,12 +632,23 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           break;
         }
 
+        await require('./workflow.js').ensureBoardConfig();
+
+        if (operation === 'context') {
+          result = await kanban.getContextPayload({
+            epic: args.epic,
+            epic_id: args.epic_id
+          });
+          break;
+        }
+
         const readOptions = normalizeReadOptions(args, 'summary');
 
         if (operation === 'list') {
           await kanban.migrateEpicGroups();
           const epics = await kanban.listEpicEntities();
-          let tasks = await kanban.allTasks();
+          const allBoardTasks = await kanban.allTasks();
+          let tasks = allBoardTasks;
           if (args.col) {
             tasks = tasks.filter((task) => task.column === args.col);
           }
@@ -610,8 +663,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             });
           }
 
-          // summary omits epic_goals; no lookup needed for list tokens
-          result = tasks.map((task) => kanban.shapeTask(task, readOptions));
+          result = tasks.map((task) => kanban.shapeTask(task, { ...readOptions, allTasks: allBoardTasks }));
         } else if (operation === 'show') {
           if (!args.task_id) {
             throw invalidRequest(
@@ -623,9 +675,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
           await kanban.migrateEpicGroups();
           const epicLookup = await buildEpicLookup();
+          const allTasks = await kanban.allTasks();
           result = kanban.shapeTask(await kanban.getTask(args.task_id), {
             ...readOptions,
-            epicLookup
+            epicLookup,
+            allTasks
           });
         } else if (operation === 'list_epics') {
           await kanban.migrateEpicGroups();
@@ -663,7 +717,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         } else {
           throw invalidRequest(
             `Unknown operation: ${operation}`,
-            'Use one of: list, show, list_epics, show_epic, help',
+            'Use one of: list, show, list_epics, show_epic, context, help',
             { operation }
           );
         }
@@ -673,9 +727,19 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'kanban_manage': {
         const action = args.action;
         const returnShape = normalizeReturnShape(args.return);
+        await require('./workflow.js').ensureBoardConfig();
 
         switch (action) {
           case 'create': {
+            let subtasks = args.subtasks;
+            if (subtasks === undefined && Array.isArray(args.steps)) {
+              subtasks = args.steps.filter(Boolean).map(String).map((text, index) => ({
+                id: `st-${index + 1}`,
+                text,
+                done: false,
+                description: ''
+              }));
+            }
             const createPayload = {
               description: args.description,
               specs: args.specs,
@@ -683,8 +747,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
               out_of_scope: args.out_of_scope,
               acceptance_criteria: args.acceptance_criteria,
               test_cases: args.test_cases,
-              subtasks: args.subtasks,
-              notes: args.notes
+              subtasks,
+              notes: args.notes,
+              depends_on: args.depends_on,
+              files: args.files
             };
             const epicRef = args.epic_id || args.epic || '—';
             const created = await kanban.doCreate(args.title, args.col || 'planned', epicRef, createPayload);
@@ -839,6 +905,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             if (args.test_cases !== undefined) patch.test_cases = args.test_cases;
             if (args.subtasks !== undefined) patch.subtasks = args.subtasks;
             if (args.notes !== undefined) patch.notes = args.notes;
+            if (args.depends_on !== undefined) patch.depends_on = args.depends_on;
+            if (args.files !== undefined) patch.files = args.files;
             if (args.adr !== undefined) patch.adr = args.adr;
             if (args.epic_id !== undefined) patch.epic_id = args.epic_id;
             else if (args.epic !== undefined) patch.epic = args.epic;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kanbango",
-  "version": "3.5.0",
+  "version": "3.8.0",
   "description": "JSON-first local Kanban board with web GUI, CLI, and MCP server",
   "main": "index.js",
   "bin": {

package/plan.js

@@ -55,17 +55,13 @@ async function detectTestRunner(projectRoot = process.cwd()) {
     }
   }
 
-  throw planError('NO_TEST_RUNNER', 'No supported test runner was found',
-    'Add a supported project manifest or set OPENCODE_TEST_COMMAND', { project_root: projectRoot });
+  return null;
 }
 
 function planSubtasks(implementationSteps) {
-  const steps = [
-    'Write tests',
-    'Run tests and confirm red',
-    ...implementationSteps,
-    'Run tests and confirm green'
-  ];
+  const steps = Array.isArray(implementationSteps)
+    ? implementationSteps.filter(Boolean).map(String)
+    : [];
   return steps.map((text, index) => ({ id: `st-${index + 1}`, text, done: false, description: '' }));
 }
 
@@ -93,6 +89,8 @@ async function create(payload = {}) {
     test_cases: payload.test_cases,
     subtasks: planSubtasks(implementationSteps),
     notes: payload.notes,
+    depends_on: payload.depends_on,
+    files: payload.files,
     plan: { runner, status: 'active' },
     evidence: []
   });
@@ -116,28 +114,30 @@ async function advance(payload = {}) {
 }
 
 async function evidence(payload = {}) {
-  const required = ['diff', 'test_command', 'stdout', 'stderr', 'exit_code'];
-  for (const field of required) {
-    if (payload[field] === undefined) {
-      throw planError('MISSING_REQUIRED_FIELD', `${field} is required`,
-        'Provide diff, test_command, stdout, stderr, and exit_code', { field });
-    }
+  const diff = payload.diff !== undefined ? String(payload.diff) : '';
+  const summary = payload.summary !== undefined ? String(payload.summary) : '';
+  const testCommand = payload.test_command !== undefined ? String(payload.test_command) : '';
+  if (!diff && !summary && !testCommand) {
+    throw planError('MISSING_REQUIRED_FIELD', 'diff, summary, or test_command is required',
+      'Provide at least one of diff, summary, or test_command', { field: 'diff' });
   }
-  if (!Number.isInteger(payload.exit_code)) {
+  if (payload.exit_code !== undefined && !Number.isInteger(payload.exit_code)) {
     throw planError('VALIDATION_ERROR', 'exit_code must be an integer',
-      'Use the process exit code from the test command', { field: 'exit_code' });
+      'Use the process exit code from the test command, or omit exit_code', { field: 'exit_code' });
   }
   const task = await kanban.getTask(payload.task_id);
-  const entry = {
-    diff: String(payload.diff),
-    test_command: String(payload.test_command),
-    stdout: String(payload.stdout),
-    stderr: String(payload.stderr),
-    exit_code: payload.exit_code,
+  const patch = { evidence: [...task.evidence, {
+    diff,
+    test_command: testCommand,
+    stdout: payload.stdout !== undefined ? String(payload.stdout) : '',
+    stderr: payload.stderr !== undefined ? String(payload.stderr) : '',
+    exit_code: Number.isInteger(payload.exit_code) ? payload.exit_code : null,
+    summary,
     created: new Date().toISOString()
-  };
-  const updated = await kanban.updateTask(task.id, { evidence: [...task.evidence, entry] });
-  return result(updated, { evidence: entry });
+  }] };
+  if (payload.files !== undefined) patch.files = payload.files;
+  const updated = await kanban.updateTask(task.id, patch);
+  return result(updated, { evidence: patch.evidence[patch.evidence.length - 1] });
 }
 
 async function done(payload = {}) {
@@ -147,8 +147,15 @@ async function done(payload = {}) {
     throw planError('PLAN_INCOMPLETE', 'Plan has incomplete subtasks',
       'Advance every plan step before marking the workflow done', { incomplete });
   }
-  const updated = await kanban.updateTask(task.id, { column: 'done', plan: { ...task.plan, status: 'done' } });
-  return result(updated, { status: 'done' });
+  const workflow = require('./workflow.js');
+  const targetColumn = await workflow.planDoneColumn();
+  const updated = await kanban.updateTask(task.id, {
+    column: targetColumn,
+    plan: { ...(task.plan || {}), status: 'done' }
+  });
+  const extra = { status: 'done', column: updated.column };
+  if (Array.isArray(updated.unblocked_tasks)) extra.unblocked_tasks = updated.unblocked_tasks;
+  return result(updated, extra);
 }
 
 async function status(taskId) {

package/tests/fixtures/fake-opencode.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * Fake opencode runner for workflow-gates tests.
+ * Env:
+ *   FAKE_OPENCODE_MODE = pass|fail|blocked|gate_pass|gate_fail|gate_missing|hang|exit1
+ *   FAKE_OPENCODE_REVIEW_MODE = gate_pass|gate_fail|gate_missing (optional; overrides when --agent is review)
+ *   FAKE_OPENCODE_ARGV_FILE = path to write JSON argv
+ *   FAKE_OPENCODE_HANG_MS = hang duration (default 60000)
+ */
+const fs = require('fs');
+const path = require('path');
+
+const args = process.argv.slice(2);
+const agentIdx = args.indexOf('--agent');
+const agent = agentIdx >= 0 ? args[agentIdx + 1] : '';
+
+let mode = String(process.env.FAKE_OPENCODE_MODE || 'pass').trim();
+const reviewMode = String(process.env.FAKE_OPENCODE_REVIEW_MODE || '').trim();
+// Review agents: prefer review mode, else map testing modes to gate_* defaults.
+if (agent === 'temida' || agent === 'review' || /temida|review/i.test(agent)) {
+  if (reviewMode) {
+    mode = reviewMode;
+  } else if (mode === 'pass') {
+    mode = 'gate_pass';
+  } else if (mode === 'fail') {
+    mode = 'gate_fail';
+  } else if (mode === 'blocked' || mode === 'gate_missing') {
+    mode = mode === 'blocked' ? 'gate_missing' : mode;
+  }
+}
+
+const argvFile = process.env.FAKE_OPENCODE_ARGV_FILE;
+if (argvFile) {
+  try {
+    fs.mkdirSync(path.dirname(argvFile), { recursive: true });
+    fs.writeFileSync(argvFile, JSON.stringify(args, null, 2) + '\n', 'utf-8');
+  } catch (err) {
+    process.stderr.write(`argv write failed: ${err.message}\n`);
+  }
+}
+
+if (mode === 'hang') {
+  const ms = Number(process.env.FAKE_OPENCODE_HANG_MS || 60000);
+  setTimeout(() => process.exit(0), ms);
+  return;
+}
+
+const outputs = {
+  pass: { out: 'Tests green\nPASS\n', code: 0 },
+  fail: { out: 'Tests red\nFAIL\n', code: 1 },
+  blocked: { out: 'Missing env\nBLOCKED\n', code: 0 },
+  gate_pass: {
+    out: 'Nagroda: solidny diff.\nKara kosmetyczna: naming.\nWedka: ok.\nGATE: PASS\n',
+    code: 0
+  },
+  gate_fail: {
+    out: 'Kara: brak testow produkcji.\nWedka: dodaj testy.\nGATE: FAIL\n',
+    code: 0
+  },
+  gate_missing: {
+    out: 'Wyrok bez markera bramki.\nTylko narracja.\n',
+    code: 0
+  },
+  exit1: { out: 'crashed without verdict\n', code: 1 }
+};
+
+const picked = outputs[mode] || outputs.pass;
+process.stdout.write(picked.out);
+process.exit(picked.code);

package/tests/index.js

@@ -0,0 +1,19 @@
+const assert = require('assert');
+const path = require('path');
+
+function run() {
+  const pkg = require(path.join(__dirname, '..', 'index.js'));
+  assert.ok(pkg.kanban, 'index exports kanban');
+  assert.ok(pkg.plan, 'index exports plan');
+  assert.ok(pkg.workflow, 'index exports workflow');
+  assert.ok(pkg.guiRegistry, 'index exports guiRegistry');
+  assert.ok(pkg.playbook, 'index exports playbook');
+  assert.ok(pkg.kanban.COLS.includes('testing'));
+  assert.ok(pkg.kanban.COLS.includes('review'));
+  assert.strictEqual(typeof pkg.workflow.loadConfig, 'function');
+  assert.strictEqual(typeof pkg.workflow.maybeEnqueueOnColumnEnter, 'function');
+  assert.strictEqual(typeof pkg.plan.done, 'function');
+  console.log('✓ index.test.js passed');
+}
+
+run();

package/tests/kanban-cli.js

@@ -0,0 +1,118 @@
+const assert = require('assert');
+const crypto = require('crypto');
+const fs = require('fs').promises;
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const PKG = path.join(__dirname, '..');
+const CLI = path.join(PKG, 'bin', 'kanban.js');
+const SRC_QA = path.join(PKG, 'agents', 'qa-tester.md');
+
+function runCli(cwd, args) {
+  return spawnSync(process.execPath, [CLI, ...args], {
+    cwd,
+    encoding: 'utf-8'
+  });
+}
+
+function sha256(content) {
+  return crypto.createHash('sha256').update(content).digest('hex');
+}
+
+async function run() {
+  // init creates testing/review dirs + README
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'kanbango-bin-'));
+  const init = runCli(root, ['init']);
+  assert.strictEqual(init.status, 0, init.stderr);
+  for (const col of ['testing', 'review', 'active', 'planned', 'icebox', 'done']) {
+    const st = await fs.stat(path.join(root, 'backlog', col));
+    assert.ok(st.isDirectory(), col);
+  }
+  const readme = await fs.readFile(path.join(root, 'backlog', 'README.md'), 'utf-8');
+  assert.ok(readme.includes('testing/'));
+  assert.ok(readme.includes('review/'));
+
+  // mcp-init --opencode copies agents + writes manifest
+  const ocRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'kanbango-bin-oc-'));
+  const oc = runCli(ocRoot, ['mcp-init', '--opencode']);
+  assert.strictEqual(oc.status, 0, oc.stderr);
+  const agentDir = path.join(ocRoot, '.opencode', 'agent');
+  const agents = await fs.readdir(agentDir);
+  assert.ok(agents.includes('qa-tester.md'));
+  assert.ok(agents.includes('temida.md'));
+  assert.ok(agents.includes('.kanbango-agents.json'));
+  const temida = await fs.readFile(path.join(agentDir, 'temida.md'), 'utf-8');
+  assert.ok(temida.includes('GATE: PASS'));
+
+  const srcQa = await fs.readFile(SRC_QA, 'utf-8');
+  const srcHash = sha256(srcQa);
+  const manifest1 = JSON.parse(await fs.readFile(path.join(agentDir, '.kanbango-agents.json'), 'utf-8'));
+  assert.strictEqual(manifest1.agents['qa-tester.md'], srcHash);
+
+  // second run, identical source → unchanged
+  const againSame = runCli(ocRoot, ['mcp-init', '--opencode']);
+  assert.strictEqual(againSame.status, 0);
+  assert.ok(againSame.stdout.includes('Bez zmian') || againSame.stdout.includes('unchanged')
+    || againSame.stdout.includes('Pominięto') === false);
+  assert.ok(againSame.stdout.includes('Bez zmian .opencode/agent/qa-tester.md'));
+  assert.strictEqual(await fs.readFile(path.join(agentDir, 'qa-tester.md'), 'utf-8'), srcQa);
+
+  // local edit while manifest matches previous package hash → conflict, keep local
+  await fs.writeFile(path.join(agentDir, 'qa-tester.md'), 'KEEP_LOCAL_EDIT', 'utf-8');
+  const conflictRun = runCli(ocRoot, ['mcp-init', '--opencode']);
+  assert.strictEqual(conflictRun.status, 0);
+  assert.ok(
+    conflictRun.stdout.includes('Konflikt') || conflictRun.stdout.includes('Pominięto'),
+    `expected conflict/skip message, got: ${conflictRun.stdout}`
+  );
+  assert.strictEqual(
+    await fs.readFile(path.join(agentDir, 'qa-tester.md'), 'utf-8'),
+    'KEEP_LOCAL_EDIT'
+  );
+
+  // clean older package version: dest matches recorded hash, source "new" → auto update
+  // Simulate by writing dest = old body, manifest hash = old hash, then force-path via
+  // restoring package content is fixed; instead write dest to old body with matching manifest.
+  const oldBody = 'OLD_PACKAGE_VERSION\n';
+  const oldHash = sha256(oldBody);
+  await fs.writeFile(path.join(agentDir, 'qa-tester.md'), oldBody, 'utf-8');
+  const man = JSON.parse(await fs.readFile(path.join(agentDir, '.kanbango-agents.json'), 'utf-8'));
+  man.agents['qa-tester.md'] = oldHash;
+  await fs.writeFile(
+    path.join(agentDir, '.kanbango-agents.json'),
+    JSON.stringify(man, null, 2) + '\n',
+    'utf-8'
+  );
+  const autoUpdate = runCli(ocRoot, ['mcp-init', '--opencode']);
+  assert.strictEqual(autoUpdate.status, 0, autoUpdate.stderr);
+  assert.ok(
+    autoUpdate.stdout.includes('Zaktualizowano .opencode/agent/qa-tester.md'),
+    autoUpdate.stdout
+  );
+  assert.strictEqual(await fs.readFile(path.join(agentDir, 'qa-tester.md'), 'utf-8'), srcQa);
+  const manAfter = JSON.parse(await fs.readFile(path.join(agentDir, '.kanbango-agents.json'), 'utf-8'));
+  assert.strictEqual(manAfter.agents['qa-tester.md'], srcHash);
+
+  // --force overwrites local edit
+  await fs.writeFile(path.join(agentDir, 'qa-tester.md'), 'FORCE_ME', 'utf-8');
+  const forceRun = runCli(ocRoot, ['mcp-init', '--opencode', '--force']);
+  assert.strictEqual(forceRun.status, 0);
+  assert.strictEqual(await fs.readFile(path.join(agentDir, 'qa-tester.md'), 'utf-8'), srcQa);
+
+  // --claude does not create .opencode/agent
+  const claudeRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'kanbango-bin-cl-'));
+  const cl = runCli(claudeRoot, ['mcp-init', '--claude']);
+  assert.strictEqual(cl.status, 0, cl.stderr);
+  await assert.rejects(
+    () => fs.access(path.join(claudeRoot, '.opencode', 'agent')),
+    (err) => err.code === 'ENOENT'
+  );
+
+  console.log('✓ bin-kanban.test.js passed');
+}
+
+run().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/tests/kanban.js

@@ -0,0 +1,104 @@
+const assert = require('assert');
+const fs = require('fs').promises;
+const os = require('os');
+const path = require('path');
+
+async function run() {
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'kanbango-kanban-'));
+  process.chdir(tempRoot);
+  const kanban = require(path.join(__dirname, '..', 'kanban.js'));
+
+  assert.ok(kanban.COLS.includes('testing'));
+  assert.ok(kanban.COLS.includes('review'));
+  assert.strictEqual(kanban.STATUS_MAP.testing, 'testing');
+  assert.strictEqual(kanban.STATUS_MAP.review, 'review');
+
+  await kanban.ensureBacklogDir();
+  for (const col of ['testing', 'review']) {
+    const st = await fs.stat(path.join(tempRoot, 'backlog', col));
+    assert.ok(st.isDirectory());
+  }
+
+  const ev = kanban.normalizeEvidence([{
+    diff: 'old',
+    test_command: 't',
+    stdout: '',
+    stderr: '',
+    exit_code: 0,
+    stage: 'testing',
+    agent: 'qa-tester',
+    verdict: 'pass',
+    summary: 'ok'
+  }]);
+  assert.strictEqual(ev[0].stage, 'testing');
+  assert.strictEqual(ev[0].verdict, 'pass');
+
+  const wf = kanban.normalizeWorkflow({
+    stage: 'review',
+    status: 'running',
+    agent: 'temida',
+    run_id: 'run-x'
+  });
+  assert.strictEqual(wf.stage, 'review');
+  assert.strictEqual(wf.status, 'running');
+
+  const task = await kanban.doCreate('Kanban unit', 'active', '—', {});
+  const moved = await kanban.updateTask(task.id, { column: 'testing' });
+  assert.strictEqual(moved.column, 'testing');
+
+  await assert.rejects(
+    () => kanban.updateTask(task.id, { column: 'done' }),
+    (err) => {
+      assert.strictEqual(err.code, 'INVALID_TRANSITION');
+      assert.deepStrictEqual(err.details.allowed_columns, ['active', 'review']);
+      assert.strictEqual(err.details.from, 'testing');
+      assert.strictEqual(err.details.to, 'done');
+      assert.ok(err.hint.includes('active, review'));
+      return true;
+    }
+  );
+  assert.deepStrictEqual(kanban.allowedColumnsFrom('active'), ['planned', 'testing', 'icebox']);
+  assert.deepStrictEqual(kanban.allowedColumnsFrom('review'), ['active', 'done']);
+  kanban.validateTransition('active', 'testing', '001');
+  kanban.validateTransition('testing', 'testing', '001');
+
+  const appended = await kanban.updateTask(task.id, {
+    appendEvidence: {
+      diff: '',
+      test_command: 'fake',
+      stdout: 'PASS',
+      stderr: '',
+      exit_code: 0,
+      stage: 'testing',
+      agent: 'qa-tester',
+      verdict: 'pass',
+      summary: 'PASS'
+    },
+    workflow: {
+      stage: 'testing',
+      status: 'pass',
+      agent: 'qa-tester',
+      run_id: 'run-1'
+    }
+  });
+  assert.ok(appended.evidence.some((e) => e.verdict === 'pass'));
+  assert.strictEqual(appended.workflow.status, 'pass');
+
+  assert.strictEqual(
+    kanban.deriveEpicStatus([{ column: 'testing' }], {}),
+    'active'
+  );
+  const progress = kanban.getEpicProgress([
+    { column: 'testing' },
+    { column: 'review' }
+  ]);
+  assert.strictEqual(progress.tasks_testing, 1);
+  assert.strictEqual(progress.tasks_review, 1);
+
+  console.log('✓ kanban.test.js passed');
+}
+
+run().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});