@stilero/bankan 1.0.13 → 1.0.17

package/server/src/store.test.js

@@ -0,0 +1,186 @@
+import { afterEach, describe, expect, test } from 'vitest';
+
+import { createRuntimeHarness } from '../test-utils.js';
+
+let harness = null;
+
+afterEach(() => {
+  harness?.cleanup();
+  harness = null;
+});
+
+describe('TaskStore persistence and recovery', () => {
+  test('addTask populates default fields and update helpers persist changes', async () => {
+    harness = createRuntimeHarness();
+    const storeModule = await harness.importModule('./src/store.js');
+    const store = storeModule.default;
+
+    const task = store.addTask({
+      title: 'Add tests',
+      priority: 'high',
+      description: 'Focus on critical paths',
+      repoPath: '/repo',
+    });
+
+    expect(task.id).toMatch(/^T-/);
+    expect(task.status).toBe('backlog');
+    expect(task.lastActiveStage).toBe('backlog');
+    expect(task.log.at(-1).message).toBe('Task created');
+
+    store.updateTask(task.id, { status: 'planning', assignedTo: 'plan-1' });
+    store.appendLog(task.id, 'Planner started');
+    store.appendSession(task.id, { id: 'session-1' });
+    store.updateTaskTokens(task.id, 250);
+    store.updateTaskTokens(task.id, 100);
+
+    const updated = store.getTask(task.id);
+    expect(updated.assignedTo).toBe('plan-1');
+    expect(updated.lastActiveStage).toBe('planning');
+    expect(updated.totalTokens).toBe(250);
+    expect(updated.sessionHistory).toEqual([{ id: 'session-1' }]);
+    expect(updated.log.map(entry => entry.message)).toEqual([
+      'Task created',
+      'Status changed to planning',
+      'Planner started',
+    ]);
+  });
+
+  test('savePlan, removePlan, and deleteTask update persisted task state', async () => {
+    harness = createRuntimeHarness();
+    const storeModule = await harness.importModule('./src/store.js');
+    const configModule = await harness.importModule('./src/config.js');
+    const store = storeModule.default;
+
+    const task = store.addTask({ title: 'Delete me' });
+    store.savePlan(task.id, 'Plan content');
+
+    expect(configModule.getRuntimeStatePaths().plansDir).toContain(harness.runtimeDir);
+
+    store.removePlan(task.id);
+    const removed = store.deleteTask(task.id);
+
+    expect(removed.id).toBe(task.id);
+    expect(store.getTask(task.id)).toBeNull();
+    expect(store.deleteTask('missing')).toBeNull();
+  });
+
+  test('restartRecovery normalizes in-flight and legacy blocked tasks', async () => {
+    harness = createRuntimeHarness();
+    const storeModule = await harness.importModule('./src/store.js');
+    const store = storeModule.default;
+
+    const planningTask = store.addTask({ title: 'Planning task', repoPath: '/repo' });
+    const reviewTask = store.addTask({ title: 'Review task', repoPath: '/repo' });
+    const pausedTask = store.addTask({ title: 'Paused task', repoPath: '/repo' });
+    const doneTask = store.addTask({ title: 'Done task', repoPath: '/repo' });
+    const legacyBlockedTask = store.addTask({
+      title: 'Legacy blocker',
+      repoPath: 'https://github.com/stilero/bankan.git',
+    });
+
+    store.updateTask(planningTask.id, { status: 'planning', assignedTo: 'plan-1' });
+    store.updateTask(reviewTask.id, { status: 'review', assignedTo: 'rev-1' });
+    store.updateTask(pausedTask.id, { status: 'paused', assignedTo: 'imp-1' });
+    store.updateTask(doneTask.id, { status: 'awaiting_human_review', assignedTo: 'rev-2', workspacePath: '/tmp/work' });
+    store.updateTask(legacyBlockedTask.id, {
+      status: 'blocked',
+      blockedReason: 'Invalid repository path: https://github.com/stilero/bankan.git',
+      workspacePath: null,
+      assignedTo: 'plan-2',
+    });
+
+    store.restartRecovery();
+
+    expect(store.getTask(planningTask.id).status).toBe('backlog');
+    expect(store.getTask(reviewTask.id).status).toBe('review');
+    expect(store.getTask(reviewTask.id).assignedTo).toBeNull();
+    expect(store.getTask(pausedTask.id).status).toBe('paused');
+    expect(store.getTask(pausedTask.id).assignedTo).toBeNull();
+    expect(store.getTask(doneTask.id).status).toBe('done');
+    expect(store.getTask(doneTask.id).workspacePath).toBeNull();
+    expect(store.getTask(legacyBlockedTask.id).status).toBe('backlog');
+    expect(store.getTask(legacyBlockedTask.id).blockedReason).toBeNull();
+  });
+
+  test('corrupt task files fall back to an empty store', async () => {
+    harness = createRuntimeHarness();
+    const configModule = await harness.importModule('./src/config.js');
+    const { writeFileSync } = await import('node:fs');
+
+    writeFileSync(configModule.getRuntimeStatePaths().tasksFile, '{not-json');
+
+    const storeModule = await harness.importModule('./src/store.js');
+    expect(storeModule.default.getAllTasks()).toEqual([]);
+  });
+
+  test('normalizes legacy task records on load and handles null update helpers', async () => {
+    harness = createRuntimeHarness();
+    const configModule = await harness.importModule('./src/config.js');
+    const { writeFileSync } = await import('node:fs');
+
+    writeFileSync(configModule.getRuntimeStatePaths().tasksFile, JSON.stringify([
+      {
+        id: 'T-LEGACY',
+        title: 'Legacy',
+        status: 'awaiting_human_review',
+        repoPath: '/repo',
+        reviewCycleCount: -2,
+        totalTokens: -10,
+        startedAt: 42,
+        completedAt: 24,
+        sessionHistory: null,
+        assignedTo: 'rev-1',
+        workspacePath: '/tmp/work',
+        log: [],
+      },
+    ]));
+
+    const storeModule = await harness.importModule('./src/store.js');
+    const store = storeModule.default;
+    const task = store.getTask('T-LEGACY');
+
+    expect(task.status).toBe('done');
+    expect(task.assignedTo).toBeNull();
+    expect(task.workspacePath).toBeNull();
+    expect(task.reviewCycleCount).toBe(0);
+    expect(task.totalTokens).toBe(0);
+    expect(task.startedAt).toBeNull();
+    expect(task.completedAt).toBeNull();
+    expect(task.sessionHistory).toEqual([]);
+
+    expect(store.updateTask('missing', { status: 'done' })).toBeNull();
+    expect(store.appendLog('missing', 'nope')).toBeNull();
+    expect(store.appendSession('missing', { id: 's-1' })).toBeNull();
+    expect(store.appendSession('T-LEGACY', null)).toBeNull();
+    expect(store.updateTaskTokens('missing', 10)).toBeNull();
+  });
+
+  test('restartRecovery handles planner-path blockers and invalid counters', async () => {
+    harness = createRuntimeHarness();
+    const storeModule = await harness.importModule('./src/store.js');
+    const store = storeModule.default;
+
+    const task = store.addTask({
+      title: 'Planner dir blocker',
+      repoPath: 'git@github.com:stilero/bankan.git',
+    });
+
+    store.updateTask(task.id, {
+      status: 'blocked',
+      blockedReason: 'Invalid planner working directory: git@github.com:stilero/bankan.git',
+      workspacePath: null,
+      reviewCycleCount: -1,
+      totalTokens: -1,
+      lastActiveStage: null,
+    });
+
+    store.restartRecovery();
+
+    const recovered = store.getTask(task.id);
+    expect(recovered.status).toBe('backlog');
+    expect(recovered.previousStatus).toBeNull();
+    expect(recovered.lastActiveStage).toBe('backlog');
+    expect(recovered.reviewCycleCount).toBe(0);
+    expect(recovered.totalTokens).toBe(0);
+  });
+});

package/server/src/workflow.js

@@ -48,10 +48,11 @@ export function isReviewResultPlaceholder(reviewText, reviewResult = parseReview
   const normalized = reviewText.replace(/\s+/g, ' ').trim().toLowerCase();
   if (normalized.includes("(issue description, or 'none')")) return true;
   if (normalized.includes('(2-3 sentences summarising the review)')) return true;
+  if (normalized.includes('concrete issue, or none')) return true;
 
   const summary = (reviewResult.summary || '').replace(/\s+/g, ' ').trim().toLowerCase();
   if (!summary) return true;
-  if (summary.includes('2-3 sentences summarising the review')) return true;
+  if (summary.includes('sentences summarising the review')) return true;
 
   return false;
 }
@@ -59,12 +60,27 @@ export function isReviewResultPlaceholder(reviewText, reviewResult = parseReview
 export function isPlanPlaceholder(planText) {
   if (typeof planText !== 'string' || !planText.trim()) return true;
   const normalized = planText.replace(/\s+/g, ' ').trim().toLowerCase();
-  if (normalized.includes('(one sentence describing what will be built)')) return true;
-  if (normalized.includes('(detailed, actionable step)')) return true;
-  if (normalized.includes('path/to/file.ts (reason for modification)')) return true;
-  if (normalized.includes("(test description, or 'none')")) return true;
-  if (normalized.includes("(potential issue or edge case, or 'none')")) return true;
-  return false;
+  const hasPlaceholder =
+    normalized.includes('(one sentence describing what will be built)') ||
+    normalized.includes('(detailed, actionable step)') ||
+    normalized.includes('path/to/file.ts (reason for modification)') ||
+    normalized.includes("(test description, or 'none')") ||
+    normalized.includes("(potential issue or edge case, or 'none')");
+
+  if (!hasPlaceholder) return false;
+
+  // Placeholder patterns found — but the plan may contain real content
+  // alongside echoed prompt template text (terminal echo contamination).
+  // Check if any SUMMARY line has substantive content.
+  const summaryMatches = [...planText.matchAll(/SUMMARY:\s*(.+)/gi)];
+  const hasRealSummary = summaryMatches.some(m => {
+    const val = m[1].trim();
+    return val.length > 20 && !val.startsWith('(');
+  });
+
+  if (hasRealSummary) return false;
+
+  return true;
 }
 
 export function getLiveTaskAgent(task, agentManager) {

package/server/src/workflow.test.js

@@ -1,16 +1,18 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
+import { describe, expect, test } from 'vitest';
 
 import {
   getLiveTaskAgent,
+  getAgentStage,
   isReviewResultPlaceholder,
+  isPlanPlaceholder,
   parseReviewResult,
   reviewShouldPass,
   stageToRetryStatus,
 } from './workflow.js';
 
-test('minor-only review output is normalized to pass', () => {
-  const reviewText = `=== REVIEW START ===
+describe('review parsing', () => {
+  test('minor-only review output is normalized to pass', () => {
+    const reviewText = `=== REVIEW START ===
 VERDICT: FAIL
 CRITICAL_ISSUES:
 - none
@@ -19,16 +21,16 @@ MINOR_ISSUES:
 SUMMARY: Only minor issues were found.
 === REVIEW END ===`;
 
-  const result = parseReviewResult(reviewText);
+    const result = parseReviewResult(reviewText);
 
-  assert.equal(result.verdict, 'FAIL');
-  assert.deepEqual(result.criticalIssues, []);
-  assert.equal(result.minorIssues.length, 1);
-  assert.equal(reviewShouldPass(result), true);
-});
+    expect(result.verdict).toBe('FAIL');
+    expect(result.criticalIssues).toEqual([]);
+    expect(result.minorIssues).toHaveLength(1);
+    expect(reviewShouldPass(result)).toBe(true);
+  });
 
-test('review with critical issues still fails', () => {
-  const reviewText = `=== REVIEW START ===
+  test('review with critical issues still fails', () => {
+    const reviewText = `=== REVIEW START ===
 VERDICT: FAIL
 CRITICAL_ISSUES:
 - server/src/orchestrator.js: review failures can loop indefinitely
@@ -37,14 +39,14 @@ MINOR_ISSUES:
 SUMMARY: A must-fix issue remains.
 === REVIEW END ===`;
 
-  const result = parseReviewResult(reviewText);
+    const result = parseReviewResult(reviewText);
 
-  assert.equal(result.hasCriticalIssues, true);
-  assert.equal(reviewShouldPass(result), false);
-});
+    expect(result.hasCriticalIssues).toBe(true);
+    expect(reviewShouldPass(result)).toBe(false);
+  });
 
-test('placeholder review template is rejected', () => {
-  const reviewText = `=== REVIEW START ===
+  test('placeholder review template is rejected', () => {
+    const reviewText = `=== REVIEW START ===
 VERDICT: PASS
 CRITICAL_ISSUES:
 - none
@@ -53,13 +55,13 @@ MINOR_ISSUES:
 SUMMARY: (2-3 sentences summarising the review)
 === REVIEW END ===`;
 
-  const result = parseReviewResult(reviewText);
+    const result = parseReviewResult(reviewText);
 
-  assert.equal(isReviewResultPlaceholder(reviewText, result), true);
-});
+    expect(isReviewResultPlaceholder(reviewText, result)).toBe(true);
+  });
 
-test('concrete review output is not treated as placeholder', () => {
-  const reviewText = `=== REVIEW START ===
+  test('concrete review output is not treated as placeholder', () => {
+    const reviewText = `=== REVIEW START ===
 VERDICT: PASS
 CRITICAL_ISSUES:
 - none
@@ -68,57 +70,200 @@ MINOR_ISSUES:
 SUMMARY: Changed files: server/src/orchestrator.js, server/src/workflow.js. The review completion gate now rejects placeholder output and the branch otherwise looks consistent with existing task flow. Strengths: the change is narrowly scoped and adds regression coverage.
 === REVIEW END ===`;
 
-  const result = parseReviewResult(reviewText);
+    const result = parseReviewResult(reviewText);
+
+    expect(isReviewResultPlaceholder(reviewText, result)).toBe(false);
+  });
+
+  test('plan placeholders are detected from default prompt scaffolding', () => {
+    expect(isPlanPlaceholder(`=== PLAN START ===
+SUMMARY: (one sentence describing what will be built)
+BRANCH: feature/example
+FILES_TO_MODIFY:
+- path/to/file.ts (reason for modification)
+STEPS:
+1. (detailed, actionable step)
+TESTS_NEEDED:
+- (test description, or 'none')
+RISKS:
+- (potential issue or edge case, or 'none')
+=== PLAN END ===`)).toBe(true);
+  });
+
+  test('review prompt template is detected as placeholder', () => {
+    const templateText = `=== REVIEW START ===
+VERDICT: PASS or FAIL
+CRITICAL_ISSUES:
+- concrete issue, or none
+MINOR_ISSUES:
+- concrete issue, or none
+SUMMARY: 2-3 concrete sentences summarising the review, including changed files and strengths
+=== REVIEW END ===`;
+    expect(isReviewResultPlaceholder(templateText)).toBe(true);
+  });
+
+  test('blank and summary-free reviews are treated as placeholders', () => {
+    expect(isReviewResultPlaceholder('')).toBe(true);
+    expect(isReviewResultPlaceholder(`=== REVIEW START ===
+VERDICT: PASS
+CRITICAL_ISSUES:
+- none
+MINOR_ISSUES:
+- none
+SUMMARY:
+=== REVIEW END ===`)).toBe(true);
+  });
+
+  test('concrete plans are not treated as placeholders', () => {
+    expect(isPlanPlaceholder(`=== PLAN START ===
+SUMMARY: Add automated tests for the workflow helpers.
+BRANCH: feature/add-workflow-tests
+FILES_TO_MODIFY:
+- server/src/workflow.test.js (expand retry and placeholder coverage)
+STEPS:
+1. Add tests for retry status edge cases.
+TESTS_NEEDED:
+- Run npm run test --prefix server
+RISKS:
+- none
+=== PLAN END ===`)).toBe(false);
+  });
+
+  test('real plan contaminated with echoed prompt template is not a placeholder', () => {
+    // When Claude CLI echoes the prompt, terminal artifacts mix template
+    // placeholder text into the real plan block after ANSI stripping.
+    const contaminated = `=== PLAN START ===
+after the delimiters: === PLAN START === SUMMARY: (one sentence describing what will be built) BRANCH: (feature/t-91eadd-short-descriptive-slug) FILES_TO_MODIFY: - path/to/file.ts (reason for modification) STEPS: 1. (detailed, actionable step) 2. (detailed, actionable step) TESTS_NEEDED: - (test description, or 'none') RISKS: - (potential issue or edge case, or 'none') === PLAN END ===
+SUMMARY: Add a Reports modal accessible from the top bar that shows per-repo task counts, total time spent, and total tokens spent with visually stunning charts.
+BRANCH: feature/t-91eadd-reports-dashboard
+FILES_TO_MODIFY:
+- client/src/ReportsModal.jsx (new reporting modal component)
+- client/src/App.jsx (add reports button and modal state)
+- server/src/index.js (add REST endpoint for aggregated task stats)
+STEPS:
+1. Create the ReportsModal component with per-repo breakdown.
+2. Wire up the top-bar button in App.jsx.
+3. Add GET /api/reports endpoint in index.js.
+TESTS_NEEDED:
+- Run npm run test to verify no regressions
+RISKS:
+- none
+=== PLAN END ===`;
+    expect(isPlanPlaceholder(contaminated)).toBe(false);
+  });
+});
+
+describe('retry status resolution', () => {
+  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) {
+        expect(id).toBe('imp-1');
+        return {
+          id: 'imp-1',
+          process: { pid: 1234 },
+          currentTask: 'T-999',
+        };
+      },
+    };
+
+    const liveAgent = getLiveTaskAgent(task, agentManager);
+    const retryStatus = stageToRetryStatus(task, { liveAgent, planningDisabled: false });
+
+    expect(liveAgent).toBeNull();
+    expect(retryStatus).toBe('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 });
+
+    expect(liveAgent).toBe(liveAgentDef);
+    expect(retryStatus).toBe('implementing');
+  });
+
+  test('planning tasks return to approval when a plan already exists', () => {
+    expect(stageToRetryStatus({
+      lastActiveStage: 'planning',
+      plan: 'ready',
+      blockedReason: '',
+    }, { planningDisabled: false })).toBe('awaiting_approval');
+  });
+
+  test('maximum review cycle blockers return to queue', () => {
+    expect(stageToRetryStatus({
+      lastActiveStage: 'review',
+      blockedReason: 'Reached maximum review cycles for this task',
+    }, { planningDisabled: false })).toBe('queued');
+  });
+
+  test('live planner and reviewer agents preserve their active stage', () => {
+    expect(stageToRetryStatus({
+      lastActiveStage: 'implementation',
+      blockedReason: '',
+    }, { liveAgent: { id: 'plan-1' }, planningDisabled: false })).toBe('planning');
+
+    expect(stageToRetryStatus({
+      lastActiveStage: 'implementation',
+      blockedReason: '',
+    }, { liveAgent: { id: 'rev-1' }, planningDisabled: false })).toBe('review');
+  });
+
+  test('planning-disabled tasks skip back to queue and backlog defaults respect planner availability', () => {
+    expect(stageToRetryStatus({
+      lastActiveStage: 'planning',
+      plan: null,
+      blockedReason: '',
+    }, { planningDisabled: true })).toBe('queued');
+
+    expect(stageToRetryStatus({
+      lastActiveStage: null,
+      blockedReason: '',
+    }, { planningDisabled: false })).toBe('backlog');
 
-  assert.equal(isReviewResultPlaceholder(reviewText, result), false);
+    expect(stageToRetryStatus({
+      lastActiveStage: null,
+      blockedReason: '',
+    }, { planningDisabled: true })).toBe('queued');
+  });
 });
 
-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');
+describe('live agent lookup', () => {
+  test('returns null when task has no assigned agent or no live process', () => {
+    expect(getLiveTaskAgent({ assignedTo: null }, { get: () => null })).toBeNull();
+    expect(getLiveTaskAgent({ assignedTo: 'imp-1', id: 'T-1' }, {
+      get: () => ({ id: 'imp-1', process: null, currentTask: 'T-1' }),
+    })).toBeNull();
+  });
 });
 
-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');
+describe('agent stage helper', () => {
+  test('maps known agent prefixes to stages', () => {
+    expect(getAgentStage('plan-2')).toBe('planning');
+    expect(getAgentStage('imp-2')).toBe('implementation');
+    expect(getAgentStage('rev-2')).toBe('review');
+    expect(getAgentStage('orch')).toBeNull();
+  });
 });