@stilero/bankan 1.0.6 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stilero/bankan",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "type": "module",
   "description": "Run AI coding agents like a Kanban board. Plan, implement, review and ship code using parallel AI agents across your local repositories.",
   "license": "MIT",

package/server/src/index.js

@@ -11,6 +11,7 @@ import config, { loadSettings, saveSettings, validateSettings, getWorkspacesDir,
 import store from './store.js';
 import agentManager from './agents.js';
 import bus from './events.js';
+import { getLiveTaskAgent, stageToRetryStatus } from './workflow.js';
 
 const app = express();
 app.use(cors());
@@ -46,28 +47,11 @@ function stageToResumeStatus(task) {
   return planningDisabled ? 'queued' : 'backlog';
 }
 
-function stageToRetryStatus(task) {
+function resolveRetryStatus(task) {
   const settings = loadSettings();
   const planningDisabled = settings.agents?.planners?.max === 0;
-  if (task.assignedTo) {
-    if (task.assignedTo.startsWith('plan-')) return 'planning';
-    if (task.assignedTo.startsWith('imp-')) return 'implementing';
-    if (task.assignedTo.startsWith('rev-')) return 'review';
-  }
-
-  if ((task.blockedReason || '').includes('maximum review cycles')) {
-    return 'queued';
-  }
-  if (task.lastActiveStage === 'review') {
-    return 'review';
-  }
-  if (task.lastActiveStage === 'implementation') {
-    return 'queued';
-  }
-  if (task.lastActiveStage === 'planning') {
-    return task.plan ? 'awaiting_approval' : (planningDisabled ? 'queued' : 'backlog');
-  }
-  return planningDisabled ? 'queued' : 'backlog';
+  const liveAgent = getLiveTaskAgent(task, agentManager);
+  return stageToRetryStatus(task, { planningDisabled, liveAgent });
 }
 
 // REST API
@@ -545,10 +529,10 @@ wss.on('connection', (ws) => {
         const { taskId } = msg.payload || {};
         const task = store.getTask(taskId);
         if (task && task.status === 'blocked') {
-          const retryStatus = stageToRetryStatus(task);
-          const agent = task.assignedTo ? agentManager.get(task.assignedTo) : null;
+          const retryStatus = resolveRetryStatus(task);
+          const agent = getLiveTaskAgent(task, agentManager);
 
-          if (agent && agent.process) {
+          if (agent) {
             agent.status = 'active';
             bus.emit('agent:updated', agent.getStatus());
           }
@@ -556,7 +540,7 @@ wss.on('connection', (ws) => {
           store.updateTask(taskId, {
             status: retryStatus,
             blockedReason: null,
-            assignedTo: agent?.process ? task.assignedTo : null,
+            assignedTo: agent ? task.assignedTo : null,
           });
           broadcast('TASK_RETRIED', { taskId, retryStatus });
         }

package/server/src/orchestrator.js

@@ -7,6 +7,7 @@ import config, { loadSettings, getWorkspacesDir } from './config.js';
 import store from './store.js';
 import agentManager from './agents.js';
 import bus from './events.js';
+import { parseReviewResult, reviewShouldPass } from './workflow.js';
 
 const POLL_INTERVAL = 4000;
 const SIGNAL_CHECK_INTERVAL = 2500;
@@ -719,20 +720,21 @@ async function onReviewComplete(agentId, taskId) {
   const sourceText = captured || bufStr;
   const reviewText = getLastStructuredBlock(sourceText, '=== REVIEW START ===', '=== REVIEW END ===');
   if (!reviewText) return;
-  const verdictMatch = reviewText.match(/VERDICT:\s*(PASS|FAIL)/i);
-  const verdict = verdictMatch ? verdictMatch[1].toUpperCase() : 'FAIL';
+  const reviewResult = parseReviewResult(reviewText);
+  const shouldPass = reviewShouldPass(reviewResult);
 
   store.updateTask(taskId, { review: reviewText });
   reviewer.kill();
   if (reviewer.draining) agentManager.removeAgent(agentId);
 
-  if (verdict === 'PASS') {
+  if (shouldPass) {
+    if (reviewResult.verdict !== 'PASS') {
+      store.appendLog(taskId, 'Reviewer returned FAIL without critical issues; normalized to PASS.');
+    }
     bus.emit('review:passed', { taskId });
     await createPR(taskId);
   } else {
-    // Extract critical issues
-    const issuesMatch = reviewText.match(/CRITICAL_ISSUES:\s*([\s\S]*?)(?=MINOR_ISSUES:|SUMMARY:|=== REVIEW END ===)/i);
-    const criticalIssues = issuesMatch ? issuesMatch[1].trim() : 'Critical issues found';
+    const criticalIssues = reviewResult.criticalIssues.join('\n');
 
     const task = store.getTask(taskId);
     const nextReviewCycleCount = (task?.reviewCycleCount || 0) + 1;

package/server/src/workflow.js

@@ -0,0 +1,71 @@
+function parseBulletList(sectionText) {
+  return (sectionText || '')
+    .split('\n')
+    .map(line => line.trim())
+    .filter(line => line.startsWith('- '))
+    .map(line => line.slice(2).trim())
+    .filter(Boolean);
+}
+
+function extractSection(text, label, nextLabels = []) {
+  if (typeof text !== 'string' || !text) return '';
+  const escapedLabel = label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const nextPattern = nextLabels.length > 0
+    ? `(?=${nextLabels.map(item => item.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|')})`
+    : '$';
+  const regex = new RegExp(`${escapedLabel}\\s*([\\s\\S]*?)${nextPattern}`, 'i');
+  const match = text.match(regex);
+  return match ? match[1].trim() : '';
+}
+
+export function parseReviewResult(reviewText) {
+  const verdictMatch = reviewText.match(/VERDICT:\s*(PASS|FAIL)/i);
+  const verdict = verdictMatch ? verdictMatch[1].toUpperCase() : 'FAIL';
+  const criticalIssues = parseBulletList(
+    extractSection(reviewText, 'CRITICAL_ISSUES:', ['MINOR_ISSUES:', 'SUMMARY:', '=== REVIEW END ==='])
+  ).filter(item => item.toLowerCase() !== 'none');
+  const minorIssues = parseBulletList(
+    extractSection(reviewText, 'MINOR_ISSUES:', ['SUMMARY:', '=== REVIEW END ==='])
+  ).filter(item => item.toLowerCase() !== 'none');
+
+  return {
+    verdict,
+    criticalIssues,
+    minorIssues,
+    hasCriticalIssues: criticalIssues.length > 0,
+  };
+}
+
+export function reviewShouldPass(reviewResult) {
+  return reviewResult.verdict === 'PASS' || !reviewResult.hasCriticalIssues;
+}
+
+export function getLiveTaskAgent(task, agentManager) {
+  if (!task?.assignedTo) return null;
+  const agent = agentManager.get(task.assignedTo);
+  if (!agent?.process) return null;
+  if (agent.currentTask !== task.id) return null;
+  return agent;
+}
+
+export function stageToRetryStatus(task, { planningDisabled = false, liveAgent = null } = {}) {
+  if (liveAgent) {
+    if (liveAgent.id.startsWith('plan-')) return 'planning';
+    if (liveAgent.id.startsWith('imp-')) return 'implementing';
+    if (liveAgent.id.startsWith('rev-')) return 'review';
+  }
+
+  if ((task.blockedReason || '').includes('maximum review cycles')) {
+    return 'queued';
+  }
+  if (task.lastActiveStage === 'review') {
+    return 'review';
+  }
+  if (task.lastActiveStage === 'implementation') {
+    return 'queued';
+  }
+  if (task.lastActiveStage === 'planning') {
+    return task.plan ? 'awaiting_approval' : (planningDisabled ? 'queued' : 'backlog');
+  }
+  return planningDisabled ? 'queued' : 'backlog';
+}

package/server/src/workflow.test.js

@@ -0,0 +1,93 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  getLiveTaskAgent,
+  parseReviewResult,
+  reviewShouldPass,
+  stageToRetryStatus,
+} from './workflow.js';
+
+test('minor-only review output is normalized to pass', () => {
+  const reviewText = `=== REVIEW START ===
+VERDICT: FAIL
+CRITICAL_ISSUES:
+- none
+MINOR_ISSUES:
+- server/src/index.js: stale status label in toast copy
+SUMMARY: Only minor issues were found.
+=== REVIEW END ===`;
+
+  const result = parseReviewResult(reviewText);
+
+  assert.equal(result.verdict, 'FAIL');
+  assert.deepEqual(result.criticalIssues, []);
+  assert.equal(result.minorIssues.length, 1);
+  assert.equal(reviewShouldPass(result), true);
+});
+
+test('review with critical issues still fails', () => {
+  const reviewText = `=== REVIEW START ===
+VERDICT: FAIL
+CRITICAL_ISSUES:
+- server/src/orchestrator.js: review failures can loop indefinitely
+MINOR_ISSUES:
+- none
+SUMMARY: A must-fix issue remains.
+=== REVIEW END ===`;
+
+  const result = parseReviewResult(reviewText);
+
+  assert.equal(result.hasCriticalIssues, true);
+  assert.equal(reviewShouldPass(result), false);
+});
+
+test('retry ignores stale assigned agent process from another task', () => {
+  const task = {
+    id: 'T-123',
+    assignedTo: 'imp-1',
+    blockedReason: 'Agent is awaiting user input',
+    lastActiveStage: 'implementation',
+  };
+  const agentManager = {
+    get(id) {
+      assert.equal(id, 'imp-1');
+      return {
+        id: 'imp-1',
+        process: { pid: 1234 },
+        currentTask: 'T-999',
+      };
+    },
+  };
+
+  const liveAgent = getLiveTaskAgent(task, agentManager);
+  const retryStatus = stageToRetryStatus(task, { liveAgent, planningDisabled: false });
+
+  assert.equal(liveAgent, null);
+  assert.equal(retryStatus, 'queued');
+});
+
+test('retry reuses live agent only when it still owns the task', () => {
+  const task = {
+    id: 'T-123',
+    assignedTo: 'imp-1',
+    blockedReason: 'Agent is awaiting user input',
+    lastActiveStage: 'implementation',
+  };
+  const liveAgentDef = {
+    id: 'imp-1',
+    process: { pid: 1234 },
+    currentTask: 'T-123',
+  };
+  const agentManager = {
+    get() {
+      return liveAgentDef;
+    },
+  };
+
+  const liveAgent = getLiveTaskAgent(task, agentManager);
+  const retryStatus = stageToRetryStatus(task, { liveAgent, planningDisabled: false });
+
+  assert.equal(liveAgent, liveAgentDef);
+  assert.equal(retryStatus, 'implementing');
+});