@agile-vibe-coding/avc 0.3.4 → 0.3.5

package/cli/seed-processor.js

@@ -779,6 +779,37 @@ Return your response as JSON following the exact structure specified in your ins
       this.debug(`[INFO] Updated story doc.md after task extraction (${storyDocContent.length} bytes)`);
     }
 
+    // Compute ready status for tasks/subtasks with no pending dependencies
+    try {
+      const { checkDependenciesReady } = await import('./dependency-checker.js');
+      const lookup = {};
+      for (const task of hierarchy.tasks) {
+        lookup[task.id] = { id: task.id, name: task.name, type: 'task', status: 'planned', dependencies: task.dependencies || [] };
+        for (const sub of task.subtasks || []) {
+          lookup[sub.id] = { id: sub.id, name: sub.name, type: 'subtask', status: 'planned', dependencies: sub.dependencies || [] };
+        }
+      }
+
+      let readyCount = 0;
+      for (const id of Object.keys(lookup)) {
+        const result = checkDependenciesReady(id, lookup);
+        if (result.ready) {
+          const itemDir = path.join(this.projectPath, id);
+          const wjPath = path.join(itemDir, 'work.json');
+          if (fs.existsSync(wjPath)) {
+            const wj = JSON.parse(fs.readFileSync(wjPath, 'utf8'));
+            wj.status = 'ready';
+            fs.writeFileSync(wjPath, JSON.stringify(wj, null, 2), 'utf8');
+            lookup[id].status = 'ready';
+            readyCount++;
+          }
+        }
+      }
+      this.debug(`[INFO] Set ${readyCount} task/subtask items to 'ready' status (dependency-free)`);
+    } catch (err) {
+      this.debug(`[WARN] Ready status computation failed (non-critical): ${err.message}`);
+    }
+
     return { taskCount, subtaskCount, taskIds };
   }
 

package/cli/worktree-runner.js

@@ -141,16 +141,21 @@ export class WorktreeRunner {
         return { success: false, error: `Tests failed: ${testResult.summary}` };
       }
 
-      // 5. Commit and merge
-      progressCallback?.('Committing and merging to main...');
+      // 5. Commit in worktree (do NOT merge — leave for human review)
+      progressCallback?.('Committing changes in worktree...');
       if (cancelledCheck?.()) throw new Error('CANCELLED');
-      this.commitAndMerge();
+      this.commitInWorktree();
 
-      // 6. Cleanup
-      progressCallback?.('Cleaning up worktree...');
-      this.cleanup();
+      // 6. Leave worktree in place for review — do NOT cleanup or merge
+      progressCallback?.(`Code ready for review in worktree: ${this.worktreePath}`);
+      progressCallback?.(`Branch: ${this.branchName}`);
 
-      return { success: true };
+      return {
+        success: true,
+        review: true,
+        worktreePath: this.worktreePath,
+        branchName: this.branchName,
+      };
     } catch (err) {
       // Always cleanup on failure
       try { this.cleanup(); } catch {}
@@ -583,28 +588,35 @@ export class WorktreeRunner {
   /**
    * Commit changes in the worktree and merge to the main branch.
    */
-  commitAndMerge() {
-    // Stage all changes
+  /**
+   * Commit all changes in the worktree (does NOT merge to main).
+   * Called after tests pass — the worktree stays in place for human review.
+   */
+  commitInWorktree() {
     git(['add', '-A'], this.worktreePath);
 
-    // Check if there's anything to commit
     const status = git(['status', '--porcelain'], this.worktreePath);
     if (!status) {
       this.debug('No changes to commit');
       return;
     }
 
-    // Commit
     const commitMsg = `feat(${this.taskId}): implement task\n\nGenerated by AVC WorktreeRunner`;
     git(['commit', '-m', commitMsg], this.worktreePath);
     this.debug('Committed in worktree');
+  }
 
+  /**
+   * Merge the worktree branch into main and clean up.
+   * Called AFTER human review approves the code (status: implemented → completed).
+   * Can be invoked via API or CLI.
+   */
+  mergeAndCleanup() {
     // Determine the main branch name
     let mainBranch = 'main';
     try {
       mainBranch = git(['symbolic-ref', '--short', 'HEAD'], this.projectRoot);
     } catch {
-      // If HEAD is detached, try common branch names
       try { git(['rev-parse', '--verify', 'main'], this.projectRoot); mainBranch = 'main'; } catch {
         try { git(['rev-parse', '--verify', 'master'], this.projectRoot); mainBranch = 'master'; } catch {}
       }
@@ -615,10 +627,12 @@ export class WorktreeRunner {
       git(['merge', '--no-ff', this.branchName, '-m', `Merge ${this.branchName}: implement ${this.taskId}`], this.projectRoot);
       this.debug('Merged to main', { mainBranch });
     } catch (err) {
-      // Merge conflict — abort and report
       try { git(['merge', '--abort'], this.projectRoot); } catch {}
       throw new Error(`Merge conflict: ${err.message}`);
     }
+
+    // Cleanup worktree and branch
+    this.cleanup();
   }
 
   /**

package/kanban/server/routes/work-items.js

@@ -289,8 +289,9 @@ export function createWorkItemsRouter(dataStore, refineService, ceremonyService)
   const VALID_TRANSITIONS = {
     'planned': ['ready', 'implementing'],
     'ready': ['implementing'],
-    'implementing': ['completed', 'failed'],
-    'failed': ['implementing'],
+    'implementing': ['implemented', 'completed', 'failed'],
+    'implemented': ['completed', 'failed'],  // review → approve (merge) or reject
+    'failed': ['implementing', 'ready'],
     'completed': [],
   };
 
@@ -328,6 +329,20 @@ export function createWorkItemsRouter(dataStore, refineService, ceremonyService)
         fsSync.writeFileSync(workJsonPath, JSON.stringify(workJson, null, 2), 'utf8');
       }
 
+      // When a task moves from 'implemented' to 'completed' (review approved),
+      // merge its worktree branch into main and clean up.
+      if (status === 'completed' && currentStatus === 'implemented' && (item._type === 'task' || item.type === 'task')) {
+        try {
+          const { WorktreeRunner } = await import('../../../cli/worktree-runner.js');
+          const runner = new WorktreeRunner(req.params.id, path.resolve(item._dirPath, '..', '..', '..', '..'));
+          runner.mergeAndCleanup();
+          console.log(`[review-merge] Merged worktree for ${req.params.id}`);
+        } catch (mergeErr) {
+          console.error(`[review-merge] Failed to merge ${req.params.id}: ${mergeErr.message}`);
+          // Non-fatal — the status is already set to completed
+        }
+      }
+
       // Reload hierarchy so in-memory state reflects the change
       await dataStore.reload();
 
@@ -376,6 +391,52 @@ export function createWorkItemsRouter(dataStore, refineService, ceremonyService)
         }
       }
 
+      // Upward cascade: propagate status to parent items
+      try {
+        const { items: freshItems } = dataStore.getHierarchy();
+        const updatedItem = freshItems.get(req.params.id);
+        let parentId = updatedItem?._parentId || null;
+        let needsReload = false;
+
+        while (parentId) {
+          const parent = freshItems.get(parentId);
+          if (!parent) break;
+
+          const children = [...freshItems.values()].filter(c => c._parentId === parentId);
+          if (children.length === 0) break;
+
+          let newParentStatus = null;
+          const allCompleted = children.every(c => c.status === 'completed');
+          const anyImplementing = children.some(c =>
+            c.status === 'implementing' || c.status === 'completed'
+          );
+
+          if (allCompleted && parent.status !== 'completed') {
+            newParentStatus = 'completed';
+          } else if (anyImplementing && parent.status !== 'implementing' && parent.status !== 'completed') {
+            newParentStatus = 'implementing';
+          }
+
+          if (newParentStatus) {
+            const parentWjPath = path.join(parent._dirPath, 'work.json');
+            if (fsSync.existsSync(parentWjPath)) {
+              const wj = JSON.parse(fsSync.readFileSync(parentWjPath, 'utf8'));
+              wj.status = newParentStatus;
+              wj.updated = new Date().toISOString();
+              fsSync.writeFileSync(parentWjPath, JSON.stringify(wj, null, 2), 'utf8');
+              needsReload = true;
+              console.log(`[status-cascade-up] ${parentId}: ${parent.status} → ${newParentStatus}`);
+            }
+          }
+
+          parentId = parent._parentId || null;
+        }
+
+        if (needsReload) await dataStore.reload();
+      } catch (upErr) {
+        console.error('Upward status cascade error (non-critical):', upErr.message);
+      }
+
       res.json({ status: 'ok', item: cleanWorkItem(item) });
     } catch (error) {
       console.error(`Error updating status for ${req.params.id}:`, error);

package/kanban/server/workers/run-task-worker.js

@@ -85,11 +85,18 @@ async function run(taskId) {
       updateStatus(taskId, 'planned'); // Reset on cancel
       try { process.send({ type: 'cancelled' }); } catch {}
     } else if (result.success) {
-      updateStatus(taskId, 'completed');
+      // Tests passed — move to review (not completed). Human must approve before merge.
+      updateStatus(taskId, 'implemented');
       try {
         process.send({
           type: 'complete',
-          result: { success: true, taskId },
+          result: {
+            success: true,
+            taskId,
+            review: true,
+            worktreePath: result.worktreePath,
+            branchName: result.branchName,
+          },
         });
       } catch {}
     } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agile-vibe-coding/avc",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "Agile Vibe Coding (AVC) - Framework for managing AI agent-based software development projects",
   "type": "module",
   "main": "cli/index.js",