@stilero/bankan 1.0.17 → 1.0.19

package/README.md

@@ -145,19 +145,16 @@ All in one dashboard.
 
 ## Why Ban Kan Exists
 
-Most AI coding workflows eventually break down in the same way:
+When developers levels up running multiple AI coding agents they often end up juggling multiple terminals:
 
-- one giant prompt tries to do planning, coding, and review
-- context grows and token usage explodes
-- agents overwrite each other’s work
-- there is no clear review stage
-- parallel development becomes chaos
+- Agent 1 planning a feature
+- Agent 2 implementing code
+- Agent 3 reviewing changes
+- Agent 4 generating tests
 
-Ban Kan fixes this with a model developers already understand:
+Keeping track of everything quickly becomes overwhelming.
 
-**a Kanban board with specialized AI agents.**
-
-Each stage has a clear responsibility, and tasks move forward only when the previous step succeeds.
+In practice most developers struggle to manage more than 3–4 agents at once.
 
 <table>
   <tr>
@@ -178,6 +175,12 @@ Each stage has a clear responsibility, and tasks move forward only when the prev
   </tr>
 </table>
 
+Ban Kan provides a control center that lets you coordinate 10+ agents simultaneously with full visibility of tasks, stages and activity.
+
+**a Kanban board with specialized AI agents.**
+
+Each stage has a clear responsibility, and tasks move forward only when the previous step succeeds.
+
 ---
 
 ## Built for Agile Development

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stilero/bankan",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "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/agents.js

@@ -45,6 +45,10 @@ const STRUCTURED_BLOCK_MARKERS = {
     start: '=== REVIEW START ===',
     end: '=== REVIEW END ===',
   },
+  implementation: {
+    start: '=== IMPLEMENTATION RESULT START ===',
+    end: '=== IMPLEMENTATION RESULT END ===',
+  },
 };
 
 function stripAnsi(text) {
@@ -108,6 +112,7 @@ class Agent {
     return {
       plan: { pending: '', completed: null, allCompleted: [] },
       review: { pending: '', completed: null, allCompleted: [] },
+      implementation: { pending: '', completed: null, allCompleted: [] },
     };
   }
 

package/server/src/orchestrator.js

@@ -7,7 +7,7 @@ import { loadSettings, getWorkspacesDir } from './config.js';
 import store from './store.js';
 import agentManager from './agents.js';
 import bus from './events.js';
-import { isReviewResultPlaceholder, isPlanPlaceholder, parseReviewResult, reviewShouldPass } from './workflow.js';
+import { isReviewResultPlaceholder, isPlanPlaceholder, isImplementationPlaceholder, parseReviewResult, reviewShouldPass } from './workflow.js';
 import { createSessionEntry } from './sessionHistory.js';
 
 const POLL_INTERVAL = 4000;
@@ -112,7 +112,7 @@ export function cleanTerminalArtifacts(text) {
   // truncate at that point — everything after is echoed prompt/template noise.
   // Also strip noise lines between the real plan content and the truncation point.
   let truncated = text;
-  for (const marker of ['=== PLAN START ===', '=== REVIEW START ===']) {
+  for (const marker of ['=== PLAN START ===', '=== REVIEW START ===', '=== IMPLEMENTATION RESULT START ===']) {
     const firstIdx = truncated.indexOf(marker);
     if (firstIdx !== -1) {
       const secondIdx = truncated.indexOf(marker, firstIdx + marker.length);
@@ -280,30 +280,61 @@ export function extractReviewerReviewText(agent, options = {}) {
   return result;
 }
 
+export function extractImplementationResult(agent, options = {}) {
+  const startMarker = '=== IMPLEMENTATION RESULT START ===';
+  const endMarker = '=== IMPLEMENTATION RESULT END ===';
+  const result = extractStructuredStageText(agent, {
+    startMarker,
+    endMarker,
+    kind: 'implementation',
+    ...options,
+  });
+
+  if (result && isImplementationPlaceholder(result)) {
+    const capturedBlocks = agent.getAllCapturedBlocks?.('implementation') || [];
+    for (let i = capturedBlocks.length - 1; i >= 0; i--) {
+      if (!isImplementationPlaceholder(capturedBlocks[i])) return capturedBlocks[i];
+    }
+
+    const cleanBuf = stripAnsi(agent.getBufferString(500));
+    const blocks = getAllStructuredBlocks(cleanBuf, startMarker, endMarker);
+    for (let i = blocks.length - 1; i >= 0; i--) {
+      if (!isImplementationPlaceholder(blocks[i])) return blocks[i];
+    }
+  }
+
+  return result;
+}
+
 function getImplementationCompletionState(agent, taskId) {
-  const completionMarker = `=== IMPLEMENTATION COMPLETE ${taskId} ===`;
-  const buf = agent.getBufferString(100);
+  const resultText = extractImplementationResult(agent);
 
+  if (resultText && !isImplementationPlaceholder(resultText)) {
+    const completionMarker = `=== IMPLEMENTATION COMPLETE ${taskId} ===`;
+    if (resultText.includes(completionMarker)) {
+      return { complete: true, blockedReason: null };
+    }
+    const blockedMatch = resultText.match(/=== BLOCKED: (.+?) ===/);
+    if (blockedMatch) {
+      return { complete: false, blockedReason: blockedMatch[1] };
+    }
+  }
+
+  // Fallback for codex: check captured message directly
   if (agent.cli === 'codex') {
+    const buf = agent.getBufferString(100);
     const captured = readCapturedCodexMessage(buf, { remove: false });
     if (captured) {
+      const completionMarker = `=== IMPLEMENTATION COMPLETE ${taskId} ===`;
       if (captured.includes(completionMarker)) {
         return { complete: true, blockedReason: null };
       }
       const blockedMatch = captured.match(/=== BLOCKED: (.+?) ===/);
       return { complete: false, blockedReason: blockedMatch ? blockedMatch[1] : null };
     }
-
-    return { complete: false, blockedReason: null };
-  }
-
-  const cleanBuf = stripAnsi(buf);
-  if (cleanBuf.includes(completionMarker)) {
-    return { complete: true, blockedReason: null };
   }
 
-  const blockedMatch = cleanBuf.match(/=== BLOCKED: (.+?) ===/);
-  return { complete: false, blockedReason: blockedMatch ? blockedMatch[1] : null };
+  return { complete: false, blockedReason: null };
 }
 
 function summarizeProcessError(prefix, err) {
@@ -514,7 +545,7 @@ RISKS:
   return prompt;
 }
 
-function buildImplementorPrompt(task, workspacePath) {
+export function buildImplementorPrompt(task, workspacePath) {
   const repoDir = workspacePath || task.repoPath;
   const promptBody = getPromptBody('implementation');
   let prompt = `You are an expert software engineer implementing a feature on a real codebase.
@@ -537,10 +568,14 @@ Instructions:
 - You are already on branch ${task.branch} in ${repoDir}
 ${promptBody}
 - Before signaling completion, ensure ALL changes are committed to git on branch ${task.branch}
-- When fully complete and all changes are committed, output this exact string on its own line:
-  === IMPLEMENTATION COMPLETE ${task.id} ===
+- When fully complete and all changes are committed, output the completion block below — replace {TASK_ID} with the actual TASK ID shown above:
+  === IMPLEMENTATION RESULT START ===
+  === IMPLEMENTATION COMPLETE {TASK_ID} ===
+  === IMPLEMENTATION RESULT END ===
 - If you encounter a blocker you cannot resolve, output:
-  === BLOCKED: {reason} ===
+  === IMPLEMENTATION RESULT START ===
+  === BLOCKED: {describe the blocker here} ===
+  === IMPLEMENTATION RESULT END ===
 
 Begin implementation now.`;
 

package/server/src/orchestrator.test.js

@@ -2,11 +2,14 @@ import { describe, expect, test, vi } from 'vitest';
 
 import {
   buildAgentCommand,
+  buildImplementorPrompt,
   cleanTerminalArtifacts,
+  extractImplementationResult,
   extractPlannerPlanText,
   extractReviewerReviewText,
   sanitizeBranchName,
 } from './orchestrator.js';
+import { isImplementationPlaceholder } from './workflow.js';
 
 describe('structured output extraction', () => {
   test('planner extraction falls back to agent structured capture when the PTY tail lost the full block', () => {
@@ -228,6 +231,131 @@ SUMMARY: Stable review capture prevents timeout.
       'Stable review capture prevents timeout.'
     );
   });
+
+  test('implementation extraction returns real completion block via structured capture', () => {
+    const readCaptured = vi.fn(() => null);
+    const realBlock = `=== IMPLEMENTATION RESULT START ===
+  === IMPLEMENTATION COMPLETE T-ABC123 ===
+  === IMPLEMENTATION RESULT END ===`;
+    const agent = {
+      cli: 'claude',
+      getBufferString: vi.fn(() => 'noise'),
+      getStructuredBlock: vi.fn(() => realBlock),
+    };
+
+    const result = extractImplementationResult(agent, { readCapturedCodexMessage: readCaptured });
+    expect(result).toContain('IMPLEMENTATION COMPLETE T-ABC123');
+  });
+
+  test('implementation extraction rejects echoed prompt template and finds real block in history', () => {
+    const readCaptured = vi.fn(() => null);
+    const templateBlock = `=== IMPLEMENTATION RESULT START ===
+  === IMPLEMENTATION COMPLETE {task.id} ===
+  === IMPLEMENTATION RESULT END ===`;
+    const realBlock = `=== IMPLEMENTATION RESULT START ===
+  === IMPLEMENTATION COMPLETE T-ABC123 ===
+  === IMPLEMENTATION RESULT END ===`;
+    const agent = {
+      cli: 'claude',
+      getBufferString: vi.fn(() => 'noise'),
+      getStructuredBlock: vi.fn(() => templateBlock),
+      getAllCapturedBlocks: vi.fn(() => [templateBlock, realBlock, templateBlock]),
+    };
+
+    const result = extractImplementationResult(agent, { readCapturedCodexMessage: readCaptured });
+    expect(result).toContain('IMPLEMENTATION COMPLETE T-ABC123');
+    expect(result).not.toContain('{task.id}');
+  });
+
+  test('implementation extraction rejects echoed prompt with {TASK_ID} placeholder and finds real block', () => {
+    // After the fix, the prompt template uses {TASK_ID} instead of the
+    // interpolated task ID, so the streaming parser captures a block with
+    // {TASK_ID} which isImplementationPlaceholder correctly rejects.
+    const readCaptured = vi.fn(() => null);
+    const echoedBlock = `=== IMPLEMENTATION RESULT START ===
+  === IMPLEMENTATION COMPLETE {TASK_ID} ===
+  === IMPLEMENTATION RESULT END ===`;
+    const realBlock = `=== IMPLEMENTATION RESULT START ===
+  === IMPLEMENTATION COMPLETE T-ABC123 ===
+  === IMPLEMENTATION RESULT END ===`;
+    const agent = {
+      cli: 'claude',
+      getBufferString: vi.fn(() => 'noise'),
+      getStructuredBlock: vi.fn(() => echoedBlock),
+      getAllCapturedBlocks: vi.fn(() => [echoedBlock, realBlock]),
+    };
+
+    const result = extractImplementationResult(agent, { readCapturedCodexMessage: readCaptured });
+    expect(result).toContain('IMPLEMENTATION COMPLETE T-ABC123');
+    expect(result).not.toContain('{TASK_ID}');
+  });
+
+  test('implementation extraction returns null when only echoed {TASK_ID} block exists', () => {
+    // When the agent has only echoed the prompt and hasn't produced real
+    // output yet, extraction should return the placeholder (which the
+    // signal checker will then reject via isImplementationPlaceholder).
+    const readCaptured = vi.fn(() => null);
+    const echoedBlock = `=== IMPLEMENTATION RESULT START ===
+  === IMPLEMENTATION COMPLETE {TASK_ID} ===
+  === IMPLEMENTATION RESULT END ===`;
+    const agent = {
+      cli: 'claude',
+      getBufferString: vi.fn(() => echoedBlock),
+      getStructuredBlock: vi.fn(() => echoedBlock),
+      getAllCapturedBlocks: vi.fn(() => [echoedBlock]),
+    };
+
+    const result = extractImplementationResult(agent, { readCapturedCodexMessage: readCaptured });
+    // Should return the placeholder block (caller checks isImplementationPlaceholder)
+    expect(result).toContain('{TASK_ID}');
+  });
+
+  test('implementation extraction falls back to buffer scan when structured capture is placeholder', () => {
+    const readCaptured = vi.fn(() => null);
+    const templateBlock = `=== IMPLEMENTATION RESULT START ===
+  === BLOCKED: {describe the blocker here} ===
+  === IMPLEMENTATION RESULT END ===`;
+    const realBlock = `=== IMPLEMENTATION RESULT START ===
+  === BLOCKED: npm install failed with EACCES ===
+  === IMPLEMENTATION RESULT END ===`;
+    const agent = {
+      cli: 'claude',
+      getBufferString: vi.fn(() => `noise\n${realBlock}\nmore noise\n${templateBlock}`),
+      getStructuredBlock: vi.fn(() => templateBlock),
+      getAllCapturedBlocks: vi.fn(() => [templateBlock]),
+    };
+
+    const result = extractImplementationResult(agent, { readCapturedCodexMessage: readCaptured });
+    expect(result).toContain('npm install failed with EACCES');
+  });
+});
+
+describe('implementation prompt echo safety', () => {
+  test('completion block in implementor prompt is detected as placeholder by isImplementationPlaceholder', () => {
+    // This is the core bug: the prompt template interpolates ${task.id} into
+    // the example completion block. When the CLI echoes the prompt, the
+    // streaming parser captures a block with the real task ID, and
+    // isImplementationPlaceholder fails to detect it as a template echo.
+    const task = {
+      id: 'T-4F66CF',
+      title: 'Reporting',
+      branch: 'feature/t-4f66cf-reporting',
+      plan: 'Add reporting feature',
+    };
+    const prompt = buildImplementorPrompt(task, '/tmp/workspace');
+
+    // Extract the completion block from the prompt the same way the
+    // streaming parser would when the CLI echoes the prompt.
+    const startMarker = '=== IMPLEMENTATION RESULT START ===';
+    const endMarker = '=== IMPLEMENTATION RESULT END ===';
+    const startIdx = prompt.indexOf(startMarker);
+    const endIdx = prompt.indexOf(endMarker, startIdx);
+    const echoedBlock = prompt.slice(startIdx, endIdx + endMarker.length);
+
+    // The echoed completion block from the prompt MUST be detected as a
+    // placeholder — otherwise the signal checker treats it as real completion.
+    expect(isImplementationPlaceholder(echoedBlock)).toBe(true);
+  });
 });
 
 describe('sanitizeBranchName', () => {

package/server/src/workflow.js

@@ -57,6 +57,23 @@ export function isReviewResultPlaceholder(reviewText, reviewResult = parseReview
   return false;
 }
 
+export function isImplementationPlaceholder(resultText) {
+  if (typeof resultText !== 'string' || !resultText.trim()) return true;
+  const normalized = resultText.replace(/\s+/g, ' ').trim().toLowerCase();
+  if (normalized.includes('{describe the blocker here}')) return true;
+  if (normalized.includes('{task_id}')) return true;
+  // The prompt template contains placeholder instruction text — if the
+  // captured block matches the template exactly it's an echo, not real output.
+  if (normalized.includes('output the completion block below with the placeholder replaced')) return true;
+  // Check for actual completion or blocked markers with real content.
+  // The prompt template contains `{task.id}` and `{describe the blocker here}` —
+  // real output has a concrete task ID (e.g. T-ABC123) or real blocker text.
+  const hasRealCompletion = /=== implementation complete t-/i.test(normalized);
+  const hasRealBlocked = /=== blocked:/.test(normalized) && !normalized.includes('{describe the blocker here}');
+  if (!hasRealCompletion && !hasRealBlocked) return true;
+  return false;
+}
+
 export function isPlanPlaceholder(planText) {
   if (typeof planText !== 'string' || !planText.trim()) return true;
   const normalized = planText.replace(/\s+/g, ' ').trim().toLowerCase();

package/server/src/workflow.test.js

@@ -3,6 +3,7 @@ import { describe, expect, test } from 'vitest';
 import {
   getLiveTaskAgent,
   getAgentStage,
+  isImplementationPlaceholder,
   isReviewResultPlaceholder,
   isPlanPlaceholder,
   parseReviewResult,
@@ -153,6 +154,56 @@ RISKS:
   });
 });
 
+describe('implementation placeholder detection', () => {
+  test('echoed prompt template is detected as placeholder', () => {
+    const template = `=== IMPLEMENTATION RESULT START ===
+  === IMPLEMENTATION COMPLETE {task.id} ===
+  === IMPLEMENTATION RESULT END ===`;
+    expect(isImplementationPlaceholder(template)).toBe(true);
+  });
+
+  test('blocked placeholder from prompt template is detected', () => {
+    const template = `=== IMPLEMENTATION RESULT START ===
+  === BLOCKED: {describe the blocker here} ===
+  === IMPLEMENTATION RESULT END ===`;
+    expect(isImplementationPlaceholder(template)).toBe(true);
+  });
+
+  test('real completion block is not a placeholder', () => {
+    const real = `=== IMPLEMENTATION RESULT START ===
+  === IMPLEMENTATION COMPLETE T-ABC123 ===
+  === IMPLEMENTATION RESULT END ===`;
+    expect(isImplementationPlaceholder(real)).toBe(false);
+  });
+
+  test('real blocked result is not a placeholder', () => {
+    const real = `=== IMPLEMENTATION RESULT START ===
+  === BLOCKED: npm install failed with EACCES ===
+  === IMPLEMENTATION RESULT END ===`;
+    expect(isImplementationPlaceholder(real)).toBe(false);
+  });
+
+  test('empty or blank text is a placeholder', () => {
+    expect(isImplementationPlaceholder('')).toBe(true);
+    expect(isImplementationPlaceholder('   ')).toBe(true);
+    expect(isImplementationPlaceholder(null)).toBe(true);
+  });
+
+  test('block without completion or blocked marker is a placeholder', () => {
+    const noise = `=== IMPLEMENTATION RESULT START ===
+some random text without markers
+=== IMPLEMENTATION RESULT END ===`;
+    expect(isImplementationPlaceholder(noise)).toBe(true);
+  });
+
+  test('echoed prompt with {TASK_ID} placeholder is detected as placeholder', () => {
+    const echoedWithPlaceholder = `=== IMPLEMENTATION RESULT START ===
+  === IMPLEMENTATION COMPLETE {TASK_ID} ===
+  === IMPLEMENTATION RESULT END ===`;
+    expect(isImplementationPlaceholder(echoedWithPlaceholder)).toBe(true);
+  });
+});
+
 describe('retry status resolution', () => {
   test('retry ignores stale assigned agent process from another task', () => {
     const task = {