@stilero/bankan 1.0.21 → 1.1.2

package/server/src/store.js

@@ -13,7 +13,7 @@ function statusToStage(status) {
   if (['workspace_setup', 'planning', 'awaiting_approval'].includes(status)) return 'planning';
   if (['queued', 'implementing'].includes(status)) return 'implementation';
   if (status === 'review') return 'review';
-  if (status === 'done') return 'done';
+  if (status === 'done' || status === 'awaiting_manual_pr') return 'done';
   if (['backlog', 'aborted'].includes(status)) return 'backlog';
   return null;
 }
@@ -61,6 +61,7 @@ class TaskStore {
         this.tasks = this.tasks.map(task => {
           const normalized = {
             reviewCycleCount: 0,
+            maxReviewCycles: 3,
             lastActiveStage: statusToStage(task.status) || 'backlog',
             previousStatus: null,
             totalTokens: 0,
@@ -80,6 +81,9 @@ class TaskStore {
           if (typeof normalized.reviewCycleCount !== 'number' || normalized.reviewCycleCount < 0) {
             normalized.reviewCycleCount = 0;
           }
+          if (typeof normalized.maxReviewCycles !== 'number' || normalized.maxReviewCycles < 1) {
+            normalized.maxReviewCycles = 3;
+          }
           if (typeof normalized.totalTokens !== 'number' || normalized.totalTokens < 0) {
             normalized.totalTokens = 0;
           }
@@ -130,6 +134,7 @@ class TaskStore {
       blockedReason: null,
       workspacePath: null,
       reviewCycleCount: 0,
+      maxReviewCycles: 3,
       lastActiveStage: 'backlog',
       previousStatus: null,
       totalTokens: 0,
@@ -245,6 +250,10 @@ class TaskStore {
         task.reviewCycleCount = 0;
         changed = true;
       }
+      if (typeof task.maxReviewCycles !== 'number' || task.maxReviewCycles < 1) {
+        task.maxReviewCycles = 3;
+        changed = true;
+      }
       if (typeof task.totalTokens !== 'number' || task.totalTokens < 0) {
         task.totalTokens = 0;
         changed = true;

package/server/src/store.test.js

@@ -26,6 +26,7 @@ describe('TaskStore persistence and recovery', () => {
     expect(task.status).toBe('backlog');
     expect(task.lastActiveStage).toBe('backlog');
     expect(task.log.at(-1).message).toBe('Task created');
+    expect(task.maxReviewCycles).toBe(3);
 
     store.updateTask(task.id, { status: 'planning', assignedTo: 'plan-1' });
     store.appendLog(task.id, 'Planner started');
@@ -125,6 +126,7 @@ describe('TaskStore persistence and recovery', () => {
         status: 'awaiting_human_review',
         repoPath: '/repo',
         reviewCycleCount: -2,
+        maxReviewCycles: -1,
         totalTokens: -10,
         startedAt: 42,
         completedAt: 24,
@@ -143,6 +145,7 @@ describe('TaskStore persistence and recovery', () => {
     expect(task.assignedTo).toBeNull();
     expect(task.workspacePath).toBeNull();
     expect(task.reviewCycleCount).toBe(0);
+    expect(task.maxReviewCycles).toBe(3);
     expect(task.totalTokens).toBe(0);
     expect(task.startedAt).toBeNull();
     expect(task.completedAt).toBeNull();
@@ -170,6 +173,7 @@ describe('TaskStore persistence and recovery', () => {
       blockedReason: 'Invalid planner working directory: git@github.com:stilero/bankan.git',
       workspacePath: null,
       reviewCycleCount: -1,
+      maxReviewCycles: -1,
       totalTokens: -1,
       lastActiveStage: null,
     });
@@ -181,6 +185,7 @@ describe('TaskStore persistence and recovery', () => {
     expect(recovered.previousStatus).toBeNull();
     expect(recovered.lastActiveStage).toBe('backlog');
     expect(recovered.reviewCycleCount).toBe(0);
+    expect(recovered.maxReviewCycles).toBe(3);
     expect(recovered.totalTokens).toBe(0);
   });
 });

package/server/src/workflow.js

@@ -42,6 +42,40 @@ export function reviewShouldPass(reviewResult) {
   return reviewResult.verdict === 'PASS' || !reviewResult.hasCriticalIssues;
 }
 
+export function isMaxReviewCyclesBlocker(blockedReason) {
+  if (typeof blockedReason !== 'string') return false;
+  return /^Reached maximum review cycles(?: \(\d+\))?/i.test(blockedReason.trim());
+}
+
+export function resolveTaskMaxReviewCycles(task, fallback = 3) {
+  const configuredValue = task?.maxReviewCycles;
+  if (typeof configuredValue === 'number' && configuredValue >= 1) {
+    return configuredValue;
+  }
+  return fallback;
+}
+
+export function buildMaxReviewBlockerApprovalUpdate(task, now = new Date().toISOString()) {
+  if (task?.status !== 'blocked' || !isMaxReviewCyclesBlocker(task?.blockedReason)) return null;
+  return {
+    status: 'done',
+    blockedReason: null,
+    assignedTo: null,
+    workspacePath: null,
+    completedAt: task.completedAt || now,
+  };
+}
+
+export function buildMaxReviewBlockerExtensionUpdate(task) {
+  if (task?.status !== 'blocked' || !isMaxReviewCyclesBlocker(task?.blockedReason)) return null;
+  return {
+    status: 'queued',
+    blockedReason: null,
+    assignedTo: null,
+    maxReviewCycles: resolveTaskMaxReviewCycles(task) + 1,
+  };
+}
+
 export function isReviewResultPlaceholder(reviewText, reviewResult = parseReviewResult(reviewText)) {
   if (typeof reviewText !== 'string' || !reviewText.trim()) return true;
 
@@ -123,7 +157,7 @@ export function stageToRetryStatus(task, { planningDisabled = false, liveAgent =
     if (stage === 'review') return 'review';
   }
 
-  if ((task.blockedReason || '').includes('maximum review cycles')) {
+  if (isMaxReviewCyclesBlocker(task.blockedReason || '')) {
     return 'queued';
   }
   if (task.lastActiveStage === 'review') {

package/server/src/workflow.test.js

@@ -1,12 +1,16 @@
 import { describe, expect, test } from 'vitest';
 
 import {
-  getLiveTaskAgent,
+  buildMaxReviewBlockerApprovalUpdate,
+  buildMaxReviewBlockerExtensionUpdate,
   getAgentStage,
+  getLiveTaskAgent,
   isImplementationPlaceholder,
-  isReviewResultPlaceholder,
+  isMaxReviewCyclesBlocker,
   isPlanPlaceholder,
+  isReviewResultPlaceholder,
   parseReviewResult,
+  resolveTaskMaxReviewCycles,
   reviewShouldPass,
   stageToRetryStatus,
 } from './workflow.js';
@@ -270,6 +274,51 @@ describe('retry status resolution', () => {
     }, { planningDisabled: false })).toBe('queued');
   });
 
+  test('maximum review cycle blockers are detected from the canonical message', () => {
+    expect(isMaxReviewCyclesBlocker('Reached maximum review cycles (3). Human input required.')).toBe(true);
+    expect(isMaxReviewCyclesBlocker('Reached maximum review cycles (3) Human input required.')).toBe(true);
+    expect(isMaxReviewCyclesBlocker('Invalid workspace path for review: /tmp/workspace')).toBe(false);
+  });
+
+  test('builds approval and extension updates for max review blockers', () => {
+    const task = {
+      status: 'blocked',
+      blockedReason: 'Reached maximum review cycles (3). Human input required.',
+      maxReviewCycles: 3,
+    };
+
+    const approved = buildMaxReviewBlockerApprovalUpdate(task);
+    const extended = buildMaxReviewBlockerExtensionUpdate(task);
+
+    expect(approved).toMatchObject({
+      status: 'done',
+      blockedReason: null,
+      assignedTo: null,
+      workspacePath: null,
+    });
+    expect(typeof approved.completedAt).toBe('string');
+    expect(extended).toEqual({
+      status: 'queued',
+      blockedReason: null,
+      assignedTo: null,
+      maxReviewCycles: 4,
+    });
+    expect(buildMaxReviewBlockerApprovalUpdate({
+      status: 'blocked',
+      blockedReason: 'Different blocker',
+    })).toBeNull();
+    expect(buildMaxReviewBlockerExtensionUpdate({
+      status: 'review',
+      blockedReason: 'Reached maximum review cycles (3). Human input required.',
+    })).toBeNull();
+  });
+
+  test('preserves an existing per-task review cap and falls back only when missing or invalid', () => {
+    expect(resolveTaskMaxReviewCycles({ maxReviewCycles: 7 }, 3)).toBe(7);
+    expect(resolveTaskMaxReviewCycles({ maxReviewCycles: 0 }, 3)).toBe(3);
+    expect(resolveTaskMaxReviewCycles({}, 3)).toBe(3);
+  });
+
   test('live planner and reviewer agents preserve their active stage', () => {
     expect(stageToRetryStatus({
       lastActiveStage: 'implementation',