@assistkick/create 1.2.0 → 1.4.0

package/templates/assistkick-product-system/packages/shared/lib/pipeline.ts

@@ -3,15 +3,36 @@
  * The full develop→review→merge cycle, using injected dependencies.
  */
 
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
 const TOOL_CALL_COUNTERS = { Write: 'write', Edit: 'edit', Read: 'read', Bash: 'bash' };
 
+const emptyStageStats = () => ({
+  toolCalls: { total: 0, write: 0, edit: 0, read: 0, bash: 0 },
+  usage: null as { input_tokens: number; output_tokens: number; cache_creation_input_tokens?: number; cache_read_input_tokens?: number } | null,
+  lastTurnUsage: null as { input_tokens: number; output_tokens: number; cache_creation_input_tokens?: number; cache_read_input_tokens?: number } | null,
+  contextWindow: null as number | null,
+  stopReason: null as string | null,
+  numTurns: null as number | null,
+  costUsd: null as number | null,
+  model: null as string | null,
+  durationMs: null as number | null,
+});
+
+const emptyAllStageStats = () => ({
+  in_progress: emptyStageStats(),
+  in_review: emptyStageStats(),
+  qa: emptyStageStats(),
+});
+
 /**
  * Pipeline class — orchestrates the develop→review→merge cycle.
  * Receives PromptBuilder, GitWorkflow, kanban, stateStore, claudeService,
  * and log via constructor injection.
  */
 export class Pipeline {
-  constructor({ promptBuilder, gitWorkflow, claudeService, kanban, paths, log, stateStore = null, workSummaryParser = null, getNode = null }) {
+  constructor({ promptBuilder, gitWorkflow, claudeService, kanban, paths, log, stateStore = null, workSummaryParser = null, getNode = null, resolveProjectWorkspace = null }) {
     this.promptBuilder = promptBuilder;
     this.gitWorkflow = gitWorkflow;
     this.claudeService = claudeService;
@@ -21,10 +42,20 @@ export class Pipeline {
     this.stateStore = stateStore;
     this.workSummaryParser = workSummaryParser;
     this.getNode = getNode;
+    this.resolveProjectWorkspace = resolveProjectWorkspace;
     this.pipelines = new Map();
     this.lastLoggedStatus = new Map();
+    // Per-feature git workflow instances (for project-scoped workspaces)
+    this.featureWorkflows = new Map();
+    // Per-feature afterMerge hooks (push to remote, etc.)
+    this.featureAfterMerge = new Map();
   }
 
+  /** Get the effective GitWorkflow for a feature (project-scoped or default). */
+  getGitWorkflow = (featureId) => {
+    return this.featureWorkflows.get(featureId) || this.gitWorkflow;
+  };
+
   /** Persist state to DB if stateStore is available (fire-and-forget with logging). */
   persistState = (featureId) => {
     if (!this.stateStore) return;
@@ -35,7 +66,8 @@ export class Pipeline {
     });
   };
 
-  run = async (featureId) => {
+  run = async (featureId, options: { startCycle?: number; skipDevForFirstCycle?: boolean } = {}) => {
+    const { startCycle = 1, skipDevForFirstCycle = false } = options;
     const state = this.pipelines.get(featureId);
     if (!state) {
       this.log('PIPELINE', `No pipeline state found for ${featureId}, aborting`);
@@ -47,94 +79,141 @@ export class Pipeline {
     let previousReviewNotes = null;
     let debuggerFindings = null;
 
-    // Debug-first step: check for unaddressed QA notes before cycle 1
-    debuggerFindings = await this.runDebugStep(featureId, state);
+    // Debug-first step: only run on a fresh start (cycle 1, no skipped dev)
+    if (startCycle === 1 && !skipDevForFirstCycle) {
+      debuggerFindings = await this.runDebugStep(featureId, state);
+    }
 
-    for (let cycle = 1; cycle <= 3; cycle++) {
+    for (let cycle = startCycle; cycle <= 3; cycle++) {
       state.cycle = cycle;
       this.log('PIPELINE', `--- Cycle ${cycle}/3 for ${featureId} ---`);
 
-      // 1. Move card to in_progress (on retries, reviewer left it in todo)
-      try {
-        const devEntry = await this.kanban.getKanbanEntry(featureId);
-        if (devEntry && devEntry.column !== 'in_progress') {
-          devEntry.column = 'in_progress';
-          devEntry.moved_at = new Date().toISOString();
-          await this.kanban.saveKanbanEntry(featureId, devEntry);
-          this.log('PIPELINE', `Moved ${featureId} → in_progress (cycle ${cycle})`);
-        }
-      } catch (err) {
-        this.log('PIPELINE', `WARN: Failed to move ${featureId} to in_progress: ${err.message}`);
-      }
+      const isFirstCycleAndSkipDev = cycle === startCycle && skipDevForFirstCycle;
 
-      // 2. Run developer
-      state.status = cycle === 1 ? 'developing' : 'fixing_review';
-      state.tasks = { completed: 0, total: 0, items: [] };
-      state.toolCalls = { total: 0, write: 0, edit: 0, read: 0, bash: 0 };
-      this.log('PIPELINE', `Status → ${state.status}`);
-      this.persistState(featureId);
-      try {
-        const devPrompt = await this.promptBuilder.buildDeveloperPrompt(featureId, cycle, previousReviewNotes, debuggerFindings, state.projectId);
-        if (cycle === 1) debuggerFindings = null;
-        this.log('PIPELINE', `Spawning developer Claude for ${featureId}...`);
-        const onToolUse = (toolName, input) => {
-          if (toolName === 'TodoWrite' && Array.isArray(input.todos)) {
-            state.tasks.items = input.todos.map(t => ({ name: t.content || t.activeForm || '', status: t.status || 'pending' }));
-            state.tasks.total = state.tasks.items.length;
-            state.tasks.completed = state.tasks.items.filter(t => t.status === 'completed').length;
-          }
-          state.toolCalls.total += 1;
-          const counterKey = TOOL_CALL_COUNTERS[toolName];
-          if (counterKey) {
-            state.toolCalls[counterKey] += 1;
+      if (!isFirstCycleAndSkipDev) {
+        // 1. Move card to in_progress (on retries, reviewer left it in todo)
+        try {
+          const devEntry = await this.kanban.getKanbanEntry(featureId);
+          if (devEntry && devEntry.column !== 'in_progress') {
+            devEntry.column = 'in_progress';
+            devEntry.moved_at = new Date().toISOString();
+            await this.kanban.saveKanbanEntry(featureId, devEntry);
+            this.log('PIPELINE', `Moved ${featureId} → in_progress (cycle ${cycle})`);
           }
-          this.persistState(featureId);
-        };
-        const devOutput = await this.claudeService.spawnClaude(devPrompt, state.worktree_path, `dev:${featureId}`, { onToolUse });
-        this.log('PIPELINE', `Developer Claude completed for ${featureId}`);
+        } catch (err) {
+          this.log('PIPELINE', `WARN: Failed to move ${featureId} to in_progress: ${err.message}`);
+        }
 
-        // Capture work summary from dev output and git diff --stat
-        await this.captureWorkSummary(featureId, state, cycle, devOutput);
-      } catch (err) {
-        this.log('PIPELINE', `Developer Claude FAILED for ${featureId}: ${err.message}`);
-        state.status = 'failed';
-        state.error = `Developer failed: ${err.message}`;
+        // 2. Run developer
+        state.status = cycle === 1 ? 'developing' : 'fixing_review';
+        state.tasks = { completed: 0, total: 0, items: [] };
+        if (!state.stageStats) state.stageStats = emptyAllStageStats();
+        state.stageStats.in_progress = emptyStageStats();
+        state.toolCalls = state.stageStats.in_progress.toolCalls;
+        this.log('PIPELINE', `Status → ${state.status}`);
         this.persistState(featureId);
-        return;
-      }
+        try {
+          const devPrompt = await this.promptBuilder.buildDeveloperPrompt(featureId, cycle, previousReviewNotes, debuggerFindings, state.projectId);
+          if (cycle === 1) debuggerFindings = null;
+          this.log('PIPELINE', `Spawning developer Claude for ${featureId}...`);
+          const onToolUse = (toolName, input) => {
+            if (toolName === 'TodoWrite' && Array.isArray(input.todos)) {
+              state.tasks.items = input.todos.map(t => ({ name: t.content || t.activeForm || '', status: t.status || 'pending' }));
+              state.tasks.total = state.tasks.items.length;
+              state.tasks.completed = state.tasks.items.filter(t => t.status === 'completed').length;
+            }
+            state.toolCalls.total += 1;
+            const counterKey = TOOL_CALL_COUNTERS[toolName];
+            if (counterKey) {
+              state.toolCalls[counterKey] += 1;
+            }
+            this.persistState(featureId);
+          };
+          const onResult = (meta) => {
+            const stage = state.stageStats.in_progress;
+            stage.usage = meta.usage;
+            stage.stopReason = meta.stopReason;
+            stage.numTurns = meta.numTurns;
+            stage.costUsd = meta.costUsd;
+            stage.model = meta.model;
+            stage.durationMs = meta.durationMs;
+            if (meta.contextWindow) stage.contextWindow = meta.contextWindow;
+            this.persistState(featureId);
+          };
+          const onTurnUsage = (usage) => {
+            state.stageStats.in_progress.lastTurnUsage = usage;
+          };
+          const devOutput = await this.claudeService.spawnClaude(devPrompt, state.worktree_path, `dev:${featureId}`, { onToolUse, onResult, onTurnUsage });
+          this.log('PIPELINE', `Developer Claude completed for ${featureId}`);
+
+          // Capture work summary from dev output and git diff --stat
+          await this.captureWorkSummary(featureId, state, cycle, devOutput);
+        } catch (err) {
+          this.log('PIPELINE', `Developer Claude FAILED for ${featureId}: ${err.message}`);
+          state.status = 'failed';
+          state.error = `Developer failed: ${err.message}`;
+          this.persistState(featureId);
+          return;
+        }
 
-      // 1b. Commit any uncommitted changes in the worktree
-      try {
-        await this.gitWorkflow.commitChanges(featureId, state.worktree_path);
-      } catch (commitErr) {
-        this.log('PIPELINE', `WARN: Auto-commit failed for ${featureId}: ${commitErr.message}`);
-      }
+        // 1b. Commit any uncommitted changes in the worktree
+        try {
+          await this.getGitWorkflow(featureId).commitChanges(featureId, state.worktree_path);
+        } catch (commitErr) {
+          this.log('PIPELINE', `WARN: Auto-commit failed for ${featureId}: ${commitErr.message}`);
+        }
 
-      // 1c. Rebase feature branch onto current main
-      await this.gitWorkflow.rebaseBranch(featureId, state.worktree_path);
+        // 1c. Rebase feature branch onto current main
+        await this.getGitWorkflow(featureId).rebaseBranch(featureId, state.worktree_path);
 
-      // 2. Pipeline moves card to in_review
-      this.log('PIPELINE', `Moving ${featureId} to in_review...`);
-      try {
-        const reviewEntry = await this.kanban.getKanbanEntry(featureId);
-        if (reviewEntry) {
-          reviewEntry.column = 'in_review';
-          reviewEntry.moved_at = new Date().toISOString();
-          await this.kanban.saveKanbanEntry(featureId, reviewEntry);
-          this.log('PIPELINE', `Moved ${featureId} → in_review`);
+        // Move card to in_review
+        this.log('PIPELINE', `Moving ${featureId} to in_review...`);
+        try {
+          const reviewEntry = await this.kanban.getKanbanEntry(featureId);
+          if (reviewEntry) {
+            reviewEntry.column = 'in_review';
+            reviewEntry.moved_at = new Date().toISOString();
+            await this.kanban.saveKanbanEntry(featureId, reviewEntry);
+            this.log('PIPELINE', `Moved ${featureId} → in_review`);
+          }
+        } catch (err) {
+          this.log('PIPELINE', `WARN: Failed to move ${featureId} to in_review: ${err.message}`);
         }
-      } catch (err) {
-        this.log('PIPELINE', `WARN: Failed to move ${featureId} to in_review: ${err.message}`);
       }
 
       // 3. Run reviewer
       state.status = 'reviewing';
+      if (!state.stageStats) state.stageStats = emptyAllStageStats();
+      state.stageStats.in_review = emptyStageStats();
       this.log('PIPELINE', `Status → reviewing`);
       this.persistState(featureId);
       try {
         const revPrompt = await this.promptBuilder.buildReviewerPrompt(featureId, state.projectId);
         this.log('PIPELINE', `Spawning reviewer Claude for ${featureId}...`);
-        await this.claudeService.spawnClaude(revPrompt, state.worktree_path, `review:${featureId}`);
+        const revToolCalls = state.stageStats.in_review.toolCalls;
+        const revOnToolUse = (toolName, _input) => {
+          revToolCalls.total += 1;
+          const counterKey = TOOL_CALL_COUNTERS[toolName];
+          if (counterKey) {
+            revToolCalls[counterKey] += 1;
+          }
+          this.persistState(featureId);
+        };
+        const revOnResult = (meta) => {
+          const stage = state.stageStats.in_review;
+          stage.usage = meta.usage;
+          stage.stopReason = meta.stopReason;
+          stage.numTurns = meta.numTurns;
+          stage.costUsd = meta.costUsd;
+          stage.model = meta.model;
+          stage.durationMs = meta.durationMs;
+          if (meta.contextWindow) stage.contextWindow = meta.contextWindow;
+          this.persistState(featureId);
+        };
+        const revOnTurnUsage = (usage) => {
+          state.stageStats.in_review.lastTurnUsage = usage;
+        };
+        await this.claudeService.spawnClaude(revPrompt, state.worktree_path, `review:${featureId}`, { onToolUse: revOnToolUse, onResult: revOnResult, onTurnUsage: revOnTurnUsage });
         this.log('PIPELINE', `Reviewer Claude completed for ${featureId}`);
       } catch (err) {
         this.log('PIPELINE', `Reviewer Claude FAILED for ${featureId}: ${err.message}`);
@@ -192,6 +271,110 @@ export class Pipeline {
     await this.handleBlock(featureId, state);
   };
 
+  resume = async (featureId) => {
+    this.log('API', `POST /api/kanban/${featureId}/resume`);
+
+    // Reject if pipeline is already actively running
+    if (this.pipelines.has(featureId)) {
+      const existing = this.pipelines.get(featureId);
+      if (!['completed', 'blocked', 'failed', 'interrupted'].includes(existing.status)) {
+        this.log('RESUME', `REJECT: pipeline already running for ${featureId} (status=${existing.status})`);
+        return { error: `Pipeline already running for ${featureId}`, status: 409 };
+      }
+    }
+
+    const entry = await this.kanban.getKanbanEntry(featureId);
+    if (!entry) {
+      this.log('RESUME', `REJECT: ${featureId} not found in kanban`);
+      return { error: `Feature "${featureId}" not found in kanban`, status: 404 };
+    }
+
+    if (!['in_progress', 'in_review'].includes(entry.column)) {
+      this.log('RESUME', `REJECT: ${featureId} not in in_progress or in_review (is in ${entry.column})`);
+      return { error: `Feature must be in "in_progress" or "in_review" column to resume (currently "${entry.column}")`, status: 400 };
+    }
+
+    // Check if worktree exists (try project workspace first, then global)
+    let worktreePath = join(this.paths.worktreesDir, featureId);
+    if (!existsSync(worktreePath)) {
+      this.log('RESUME', `Worktree missing for ${featureId} — falling back to fresh start`);
+      // Move card back to todo so start() validation passes
+      entry.column = 'todo';
+      entry.moved_at = new Date().toISOString();
+      await this.kanban.saveKanbanEntry(featureId, entry);
+      return await this.start(featureId);
+    }
+
+    // Load persisted state for cycle number
+    let startCycle = 1;
+    if (this.stateStore) {
+      try {
+        const dbState = await this.stateStore.load(featureId);
+        if (dbState && dbState.cycle) {
+          startCycle = dbState.cycle;
+          this.log('RESUME', `Resuming ${featureId} from cycle ${startCycle} (from DB state)`);
+        }
+      } catch (err) {
+        this.log('RESUME', `WARN: Failed to load DB state for ${featureId}: ${err.message} — using cycle 1`);
+      }
+    }
+
+    // If card is in_review, the developer step already completed — skip it
+    const skipDevForFirstCycle = entry.column === 'in_review';
+    this.log('RESUME', `${featureId}: column=${entry.column} startCycle=${startCycle} skipDev=${skipDevForFirstCycle}`);
+
+    // Look up projectId
+    let projectId = null;
+    if (this.getNode) {
+      try {
+        const node = await this.getNode(featureId);
+        if (node) projectId = node.project_id || null;
+      } catch {}
+    }
+
+    // Resolve project workspace for resume
+    if (projectId && this.resolveProjectWorkspace) {
+      try {
+        const workspace = await this.resolveProjectWorkspace(projectId);
+        if (workspace) {
+          this.featureWorkflows.set(featureId, workspace.gitWorkflow);
+          if (workspace.afterMerge) {
+            this.featureAfterMerge.set(featureId, workspace.afterMerge);
+          }
+          this.log('RESUME', `Using project workspace for ${featureId} (project ${projectId})`);
+        }
+      } catch (err) {
+        this.log('RESUME', `WARN: Failed to resolve project workspace: ${err.message} — using default`);
+      }
+    }
+
+    const stageStats = emptyAllStageStats();
+    const initialStage = skipDevForFirstCycle ? 'in_review' : 'in_progress';
+    const state = {
+      status: skipDevForFirstCycle ? 'reviewing' : 'developing',
+      cycle: startCycle,
+      worktree_path: worktreePath,
+      process: null,
+      error: null,
+      tasks: { completed: 0, total: 0, items: [] },
+      toolCalls: stageStats[initialStage].toolCalls,
+      workSummaries: [],
+      projectId,
+      stageStats,
+    };
+    this.pipelines.set(featureId, state);
+    this.persistState(featureId);
+    this.log('RESUME', `Launching async pipeline resume for ${featureId}...`);
+
+    this.run(featureId, { startCycle, skipDevForFirstCycle }).catch(err => {
+      this.log('RESUME', `Pipeline UNCAUGHT ERROR for ${featureId}: ${err.message}`);
+      const s = this.pipelines.get(featureId);
+      if (s) { s.status = 'failed'; s.error = err.message; this.persistState(featureId); }
+    });
+
+    return { resumed: true, feature_id: featureId, status: 200 };
+  };
+
   /** Capture work summary after a developer cycle completes. */
   captureWorkSummary = async (featureId, state, cycle, devOutput) => {
     if (!this.workSummaryParser) return;
@@ -260,6 +443,7 @@ export class Pipeline {
   };
 
   handleMerge = async (featureId, state) => {
+    const gw = this.getGitWorkflow(featureId);
     state.status = 'merging';
     this.log('PIPELINE', `Status → merging`);
     this.persistState(featureId);
@@ -267,7 +451,7 @@ export class Pipeline {
     // Step 1: Stash any local changes on the parent branch before merging
     let stashed = false;
     try {
-      stashed = await this.gitWorkflow.stash();
+      stashed = await gw.stash();
     } catch (stashErr) {
       this.log('PIPELINE', `Stash failed (non-fatal): ${stashErr.message}`);
     }
@@ -275,7 +459,7 @@ export class Pipeline {
     // Step 2: Merge the feature branch
     let mergeSucceeded = false;
     try {
-      await this.gitWorkflow.mergeBranch(featureId);
+      await gw.mergeBranch(featureId);
       mergeSucceeded = true;
     } catch (mergeErr) {
       this.log('PIPELINE', `Merge FAILED: ${mergeErr.message} — attempting fix`);
@@ -283,7 +467,7 @@ export class Pipeline {
       this.log('PIPELINE', `Status → fixing_merge`);
       this.persistState(featureId);
       try {
-        const fixed = await this.gitWorkflow.fixMergeConflicts(featureId);
+        const fixed = await gw.fixMergeConflicts(featureId);
         if (fixed) {
           this.log('PIPELINE', `Merge fix succeeded — branch verified as merged`);
           mergeSucceeded = true;
@@ -304,7 +488,7 @@ export class Pipeline {
     // Step 3: Pop stash to restore local changes
     if (stashed) {
       try {
-        await this.gitWorkflow.unstash();
+        await gw.unstash();
       } catch (popErr) {
         this.log('PIPELINE', `Stash pop failed — changes remain in stash: ${popErr.message}`);
       }
@@ -313,15 +497,32 @@ export class Pipeline {
     // Step 4: Cleanup worktree + branch
     if (mergeSucceeded) {
       this.log('PIPELINE', `Cleaning up worktree and branch for ${featureId}...`);
-      await this.gitWorkflow.removeWorktree(state.worktree_path);
-      await this.gitWorkflow.deleteBranch(featureId);
+      await gw.removeWorktree(state.worktree_path);
+      await gw.deleteBranch(featureId);
+
+      // Step 5: Push to remote after merge (if project has a connected repo)
+      const afterMerge = this.featureAfterMerge.get(featureId);
+      if (afterMerge) {
+        try {
+          await afterMerge();
+          this.log('PIPELINE', `Post-merge push completed for ${featureId}`);
+        } catch (pushErr) {
+          this.log('PIPELINE', `Post-merge push FAILED (non-fatal): ${pushErr.message}`);
+        }
+      }
+
       state.status = 'completed';
       this.log('PIPELINE', `=== Pipeline COMPLETED for ${featureId} ===`);
       this.persistState(featureId);
+
+      // Cleanup per-feature state
+      this.featureWorkflows.delete(featureId);
+      this.featureAfterMerge.delete(featureId);
     }
   };
 
   handleBlock = async (featureId, state) => {
+    const gw = this.getGitWorkflow(featureId);
     this.log('PIPELINE', `=== All 3 cycles exhausted for ${featureId} — BLOCKING ===`);
     try {
       const blockEntry = await this.kanban.getKanbanEntry(featureId);
@@ -331,14 +532,18 @@ export class Pipeline {
         this.log('PIPELINE', `Set dev_blocked=true for ${featureId}`);
       }
       this.log('PIPELINE', `Cleaning up worktree for ${featureId}...`);
-      await this.gitWorkflow.removeWorktree(state.worktree_path);
-      await this.gitWorkflow.deleteBranch(featureId, true);
+      await gw.removeWorktree(state.worktree_path);
+      await gw.deleteBranch(featureId, true);
     } catch (err) {
       this.log('PIPELINE', `Block/cleanup error (non-fatal): ${err.message}`);
     }
     state.status = 'blocked';
     this.log('PIPELINE', `=== Pipeline BLOCKED for ${featureId} ===`);
     this.persistState(featureId);
+
+    // Cleanup per-feature state
+    this.featureWorkflows.delete(featureId);
+    this.featureAfterMerge.delete(featureId);
   };
 
   start = async (featureId) => {
@@ -372,10 +577,39 @@ export class Pipeline {
       return { error: `Feature "${featureId}" is dev_blocked. Unblock it first.`, status: 400 };
     }
 
+    // Look up the projectId from the feature node
+    let projectId = null;
+    if (this.getNode) {
+      try {
+        const node = await this.getNode(featureId);
+        if (node) projectId = node.project_id || null;
+      } catch {}
+    }
+
+    // Resolve project workspace: creates a project-scoped GitWorkflow if configured
+    let effectiveGitWorkflow = this.gitWorkflow;
+    if (projectId && this.resolveProjectWorkspace) {
+      try {
+        const workspace = await this.resolveProjectWorkspace(projectId);
+        if (workspace) {
+          effectiveGitWorkflow = workspace.gitWorkflow;
+          this.featureWorkflows.set(featureId, workspace.gitWorkflow);
+          if (workspace.afterMerge) {
+            this.featureAfterMerge.set(featureId, workspace.afterMerge);
+          }
+          this.log('DEVELOP', `Using project workspace for ${featureId} (project ${projectId})`);
+        }
+      } catch (err) {
+        this.log('DEVELOP', `WARN: Failed to resolve project workspace: ${err.message} — using default`);
+      }
+    }
+
     // Pre-flight: reject if working tree is dirty to avoid stash conflicts on merge
-    const dirtyFiles = await this.gitWorkflow.getDirtyFiles();
+    const dirtyFiles = await effectiveGitWorkflow.getDirtyFiles();
     if (dirtyFiles.length > 0) {
       this.log('DEVELOP', `REJECT: working tree has ${dirtyFiles.length} uncommitted change(s)`);
+      this.featureWorkflows.delete(featureId);
+      this.featureAfterMerge.delete(featureId);
       return { error: `Working tree has uncommitted changes. Commit or stash them before starting a pipeline.\n${dirtyFiles.join('\n')}`, status: 400 };
     }
 
@@ -385,29 +619,32 @@ export class Pipeline {
     await this.kanban.saveKanbanEntry(featureId, entry);
     this.log('DEVELOP', `Moved ${featureId} to in_progress`);
 
+    // Pull latest before creating worktree (ensure up-to-date base)
+    if (effectiveGitWorkflow !== this.gitWorkflow) {
+      try {
+        await effectiveGitWorkflow.pullDefaultBranch();
+      } catch (pullErr) {
+        this.log('DEVELOP', `WARN: Pull before worktree failed: ${pullErr.message}`);
+      }
+    }
+
     // Create worktree
     let worktreePath;
     try {
-      worktreePath = await this.gitWorkflow.createWorktree(featureId);
+      worktreePath = await effectiveGitWorkflow.createWorktree(featureId);
     } catch (err) {
       this.log('DEVELOP', `Worktree creation FAILED: ${err.message}`);
       // Revert kanban change
       entry.column = 'todo';
       await this.kanban.saveKanbanEntry(featureId, entry);
       this.log('DEVELOP', `Reverted ${featureId} back to todo`);
+      this.featureWorkflows.delete(featureId);
+      this.featureAfterMerge.delete(featureId);
       return { error: `Failed to create worktree: ${err.message}`, status: 500 };
     }
 
-    // Look up the projectId from the feature node
-    let projectId = null;
-    if (this.getNode) {
-      try {
-        const node = await this.getNode(featureId);
-        if (node) projectId = node.project_id || null;
-      } catch {}
-    }
-
-    const state = { status: 'developing', cycle: 1, worktree_path: worktreePath, process: null, error: null, tasks: { completed: 0, total: 0, items: [] }, toolCalls: { total: 0, write: 0, edit: 0, read: 0, bash: 0 }, workSummaries: [], projectId };
+    const stageStats = emptyAllStageStats();
+    const state = { status: 'developing', cycle: 1, worktree_path: worktreePath, process: null, error: null, tasks: { completed: 0, total: 0, items: [] }, toolCalls: stageStats.in_progress.toolCalls, workSummaries: [], projectId, stageStats };
     this.pipelines.set(featureId, state);
     this.persistState(featureId);
     this.log('DEVELOP', `Pipeline state initialized for ${featureId}`);
@@ -460,6 +697,9 @@ export class Pipeline {
     if (state.workSummaries && state.workSummaries.length > 0) {
       result.workSummaries = state.workSummaries;
     }
+    if (state.stageStats) {
+      result.stageStats = state.stageStats;
+    }
     return result;
   };