agileflow 2.85.0 → 2.87.0

package/scripts/session-manager.js

@@ -117,19 +117,39 @@ function isSessionActive(sessionId) {
   return isPidAlive(parseInt(lock.pid, 10));
 }
 
-// Clean up stale locks
-function cleanupStaleLocks(registry) {
+// Clean up stale locks (with detailed tracking)
+function cleanupStaleLocks(registry, options = {}) {
+  const { verbose = false, dryRun = false } = options;
   let cleaned = 0;
+  const cleanedSessions = [];
 
   for (const [id, session] of Object.entries(registry.sessions)) {
     const lock = readLock(id);
-    if (lock && !isPidAlive(parseInt(lock.pid, 10))) {
-      removeLock(id);
-      cleaned++;
+    if (lock) {
+      const pid = parseInt(lock.pid, 10);
+      const isAlive = isPidAlive(pid);
+
+      if (!isAlive) {
+        // Track what we're cleaning and why
+        cleanedSessions.push({
+          id,
+          nickname: session.nickname,
+          branch: session.branch,
+          pid,
+          reason: 'pid_dead',
+          path: session.path,
+        });
+
+        if (!dryRun) {
+          removeLock(id);
+        }
+        cleaned++;
+      }
     }
   }
 
-  return cleaned;
+  // Return detailed info for display
+  return { count: cleaned, sessions: cleanedSessions };
 }
 
 // Get current git branch
@@ -156,8 +176,21 @@ function getCurrentStory() {
   return null;
 }
 
+// Thread type enum values
+const THREAD_TYPES = ['base', 'parallel', 'chained', 'fusion', 'big', 'long'];
+
+// Auto-detect thread type from context
+function detectThreadType(session, isWorktree = false) {
+  // Worktree sessions are parallel threads
+  if (isWorktree || (session && !session.is_main)) {
+    return 'parallel';
+  }
+  // Default to base
+  return 'base';
+}
+
 // Register current session (called on startup)
-function registerSession(nickname = null) {
+function registerSession(nickname = null, threadType = null) {
   const registry = loadRegistry();
   const cwd = process.cwd();
   const branch = getCurrentBranch();
@@ -179,6 +212,10 @@ function registerSession(nickname = null) {
     registry.sessions[existingId].story = story ? story.id : null;
     registry.sessions[existingId].last_active = new Date().toISOString();
     if (nickname) registry.sessions[existingId].nickname = nickname;
+    // Update thread_type if explicitly provided
+    if (threadType && THREAD_TYPES.includes(threadType)) {
+      registry.sessions[existingId].thread_type = threadType;
+    }
 
     writeLock(existingId, pid);
     saveRegistry(registry);
@@ -190,6 +227,11 @@ function registerSession(nickname = null) {
   const sessionId = String(registry.next_id);
   registry.next_id++;
 
+  const isMain = cwd === ROOT;
+  const detectedType = threadType && THREAD_TYPES.includes(threadType)
+    ? threadType
+    : detectThreadType(null, !isMain);
+
   registry.sessions[sessionId] = {
     path: cwd,
     branch,
@@ -197,13 +239,14 @@ function registerSession(nickname = null) {
     nickname: nickname || null,
     created: new Date().toISOString(),
     last_active: new Date().toISOString(),
-    is_main: cwd === ROOT,
+    is_main: isMain,
+    thread_type: detectedType,
   };
 
   writeLock(sessionId, pid);
   saveRegistry(registry);
 
-  return { id: sessionId, isNew: true };
+  return { id: sessionId, isNew: true, thread_type: detectedType };
 }
 
 // Unregister session (called on exit)
@@ -291,7 +334,7 @@ function createSession(options = {}) {
     };
   }
 
-  // Register session
+  // Register session - worktree sessions are always parallel threads
   registry.next_id++;
   registry.sessions[sessionId] = {
     path: worktreePath,
@@ -301,6 +344,7 @@ function createSession(options = {}) {
     created: new Date().toISOString(),
     last_active: new Date().toISOString(),
     is_main: false,
+    thread_type: options.thread_type || 'parallel', // Worktrees default to parallel
   };
 
   saveRegistry(registry);
@@ -310,6 +354,7 @@ function createSession(options = {}) {
     sessionId,
     path: worktreePath,
     branch: branchName,
+    thread_type: registry.sessions[sessionId].thread_type,
     command: `cd "${worktreePath}" && claude`,
   };
 }
@@ -317,7 +362,7 @@ function createSession(options = {}) {
 // Get all sessions with status
 function getSessions() {
   const registry = loadRegistry();
-  const cleaned = cleanupStaleLocks(registry);
+  const cleanupResult = cleanupStaleLocks(registry);
 
   const sessions = [];
   for (const [id, session] of Object.entries(registry.sessions)) {
@@ -332,7 +377,12 @@ function getSessions() {
   // Sort by ID (numeric)
   sessions.sort((a, b) => parseInt(a.id) - parseInt(b.id));
 
-  return { sessions, cleaned };
+  // Return count for backward compat, plus detailed info
+  return {
+    sessions,
+    cleaned: cleanupResult.count,
+    cleanedSessions: cleanupResult.sessions,
+  };
 }
 
 // Get count of active sessions (excluding current)
@@ -671,6 +721,172 @@ function integrateSession(sessionId, options = {}) {
   return result;
 }
 
+// Session phases for Kanban-style visualization
+const SESSION_PHASES = {
+  TODO: 'todo',
+  CODING: 'coding',
+  REVIEW: 'review',
+  MERGED: 'merged',
+};
+
+// Detect session phase based on git state
+function getSessionPhase(session) {
+  // If merged_at field exists, session was merged
+  if (session.merged_at) {
+    return SESSION_PHASES.MERGED;
+  }
+
+  // If is_main, it's the merged/main column
+  if (session.is_main) {
+    return SESSION_PHASES.MERGED;
+  }
+
+  // Check git state for the session
+  try {
+    const sessionPath = session.path;
+    if (!fs.existsSync(sessionPath)) {
+      return SESSION_PHASES.TODO;
+    }
+
+    // Count commits since branch diverged from main
+    const mainBranch = getMainBranch();
+    const commitCount = execSync(
+      `git rev-list --count ${mainBranch}..HEAD 2>/dev/null || echo 0`,
+      { cwd: sessionPath, encoding: 'utf8' }
+    ).trim();
+
+    const commits = parseInt(commitCount, 10);
+
+    if (commits === 0) {
+      return SESSION_PHASES.TODO;
+    }
+
+    // Check for uncommitted changes
+    const status = execSync('git status --porcelain 2>/dev/null || echo ""', {
+      cwd: sessionPath,
+      encoding: 'utf8',
+    }).trim();
+
+    if (status === '') {
+      // No uncommitted changes = ready for review
+      return SESSION_PHASES.REVIEW;
+    }
+
+    // Has commits but also uncommitted changes = still coding
+    return SESSION_PHASES.CODING;
+  } catch (e) {
+    // On error, assume coding phase
+    return SESSION_PHASES.CODING;
+  }
+}
+
+// Render Kanban-style board visualization
+function renderKanbanBoard(sessions) {
+  const lines = [];
+
+  // Group sessions by phase
+  const byPhase = {
+    [SESSION_PHASES.TODO]: [],
+    [SESSION_PHASES.CODING]: [],
+    [SESSION_PHASES.REVIEW]: [],
+    [SESSION_PHASES.MERGED]: [],
+  };
+
+  for (const session of sessions) {
+    const phase = getSessionPhase(session);
+    byPhase[phase].push(session);
+  }
+
+  // Calculate column widths (min 12 chars)
+  const colWidth = 14;
+  const separator = '  ';
+
+  // Header
+  lines.push(`${c.cyan}Sessions (Kanban View):${c.reset}`);
+  lines.push('');
+
+  // Column headers
+  const headers = [
+    `${c.dim}TO DO${c.reset}`,
+    `${c.yellow}CODING${c.reset}`,
+    `${c.blue}REVIEW${c.reset}`,
+    `${c.green}MERGED${c.reset}`,
+  ];
+  lines.push(headers.map(h => h.padEnd(colWidth + 10)).join(separator)); // +10 for ANSI codes
+
+  // Top borders
+  const topBorder = `┌${'─'.repeat(colWidth)}┐`;
+  lines.push([topBorder, topBorder, topBorder, topBorder].join(separator));
+
+  // Find max rows needed
+  const maxRows = Math.max(
+    1,
+    byPhase[SESSION_PHASES.TODO].length,
+    byPhase[SESSION_PHASES.CODING].length,
+    byPhase[SESSION_PHASES.REVIEW].length,
+    byPhase[SESSION_PHASES.MERGED].length
+  );
+
+  // Render rows
+  for (let i = 0; i < maxRows; i++) {
+    const cells = [
+      SESSION_PHASES.TODO,
+      SESSION_PHASES.CODING,
+      SESSION_PHASES.REVIEW,
+      SESSION_PHASES.MERGED,
+    ].map(phase => {
+      const session = byPhase[phase][i];
+      if (!session) {
+        return `│${' '.repeat(colWidth)}│`;
+      }
+
+      // Format session info
+      const id = `[${session.id}]`;
+      const name = session.nickname || session.branch || '';
+      const truncName = name.length > colWidth - 5 ? name.slice(0, colWidth - 8) + '...' : name;
+      const content = `${id} ${truncName}`.slice(0, colWidth);
+
+      return `│${content.padEnd(colWidth)}│`;
+    });
+    lines.push(cells.join(separator));
+
+    // Second line with story
+    const storyCells = [
+      SESSION_PHASES.TODO,
+      SESSION_PHASES.CODING,
+      SESSION_PHASES.REVIEW,
+      SESSION_PHASES.MERGED,
+    ].map(phase => {
+      const session = byPhase[phase][i];
+      if (!session) {
+        return `│${' '.repeat(colWidth)}│`;
+      }
+
+      const story = session.story || '-';
+      const storyTrunc = story.length > colWidth - 2 ? story.slice(0, colWidth - 5) + '...' : story;
+
+      return `│${c.dim}${storyTrunc.padEnd(colWidth)}${c.reset}│`;
+    });
+    lines.push(storyCells.join(separator));
+  }
+
+  // Bottom borders
+  const bottomBorder = `└${'─'.repeat(colWidth)}┘`;
+  lines.push([bottomBorder, bottomBorder, bottomBorder, bottomBorder].join(separator));
+
+  // Summary
+  lines.push('');
+  const summary = [
+    `${c.dim}To Do: ${byPhase[SESSION_PHASES.TODO].length}${c.reset}`,
+    `${c.yellow}Coding: ${byPhase[SESSION_PHASES.CODING].length}${c.reset}`,
+    `${c.blue}Review: ${byPhase[SESSION_PHASES.REVIEW].length}${c.reset}`,
+    `${c.green}Merged: ${byPhase[SESSION_PHASES.MERGED].length}${c.reset}`,
+  ].join(' │ ');
+  lines.push(summary);
+
+  return lines.join('\n');
+}
+
 // Format sessions for display
 function formatSessionsTable(sessions) {
   const lines = [];
@@ -747,6 +963,11 @@ function main() {
       const { sessions, cleaned } = getSessions();
       if (args.includes('--json')) {
         console.log(JSON.stringify({ sessions, cleaned }));
+      } else if (args.includes('--kanban')) {
+        console.log(renderKanbanBoard(sessions));
+        if (cleaned > 0) {
+          console.log(`${c.dim}Cleaned ${cleaned} stale lock(s)${c.reset}`);
+        }
       } else {
         console.log(formatSessionsTable(sessions));
         if (cleaned > 0) {
@@ -793,7 +1014,7 @@ function main() {
 
       // Register in single pass (combines register + count + status)
       const registry = loadRegistry();
-      const cleaned = cleanupStaleLocks(registry);
+      const cleanupResult = cleanupStaleLocks(registry);
       const branch = getCurrentBranch();
       const story = getCurrentStory();
       const pid = process.ppid || process.pid;
@@ -814,11 +1035,16 @@ function main() {
         registry.sessions[sessionId].story = story ? story.id : null;
         registry.sessions[sessionId].last_active = new Date().toISOString();
         if (nickname) registry.sessions[sessionId].nickname = nickname;
+        // Ensure thread_type exists (migration for old sessions)
+        if (!registry.sessions[sessionId].thread_type) {
+          registry.sessions[sessionId].thread_type = registry.sessions[sessionId].is_main ? 'base' : 'parallel';
+        }
         writeLock(sessionId, pid);
       } else {
         // Create new
         sessionId = String(registry.next_id);
         registry.next_id++;
+        const isMain = cwd === ROOT;
         registry.sessions[sessionId] = {
           path: cwd,
           branch,
@@ -826,7 +1052,8 @@ function main() {
           nickname: nickname || null,
           created: new Date().toISOString(),
           last_active: new Date().toISOString(),
-          is_main: cwd === ROOT,
+          is_main: isMain,
+          thread_type: isMain ? 'base' : 'parallel',
         };
         writeLock(sessionId, pid);
         isNew = true;
@@ -853,7 +1080,8 @@ function main() {
           current,
           otherActive,
           total: sessions.length,
-          cleaned,
+          cleaned: cleanupResult.count,
+          cleanedSessions: cleanupResult.sessions,
         })
       );
       break;
@@ -984,6 +1212,26 @@ function main() {
       break;
     }
 
+    case 'thread-type': {
+      const subCommand = args[1];
+      if (subCommand === 'set') {
+        const sessionId = args[2];
+        const threadType = args[3];
+        if (!sessionId || !threadType) {
+          console.log(JSON.stringify({ success: false, error: 'Usage: thread-type set <sessionId> <type>' }));
+          return;
+        }
+        const result = setSessionThreadType(sessionId, threadType);
+        console.log(JSON.stringify(result));
+      } else {
+        // Default: get thread type
+        const sessionId = args[1] || null;
+        const result = getSessionThreadType(sessionId);
+        console.log(JSON.stringify(result));
+      }
+      break;
+    }
+
     case 'help':
     default:
       console.log(`
@@ -1001,6 +1249,8 @@ ${c.cyan}Commands:${c.reset}
   switch <id|nickname>    Switch active session context (for /add-dir)
   active                  Get currently switched session (if any)
   clear-active            Clear switched session (back to main)
+  thread-type [id]        Get thread type for session (default: current)
+  thread-type set <id> <type>  Set thread type (base|parallel|chained|fusion|big|long)
   check-merge <id>        Check if session is mergeable to main
   merge-preview <id>      Preview commits/files to be merged
   integrate <id> [opts]   Merge session to main and cleanup
@@ -1186,7 +1436,7 @@ function smartMerge(sessionId, options = {}) {
   }
 
   // Categorize and plan resolutions
-  const resolutions = conflictFiles.files.map((file) => {
+  const resolutions = conflictFiles.files.map(file => {
     const category = categorizeFile(file);
     const strategyInfo = getMergeStrategy(category);
     return {
@@ -1295,7 +1545,10 @@ function smartMerge(sessionId, options = {}) {
         result.worktreeDeleted = true;
       } catch (e) {
         try {
-          execSync(`git worktree remove --force "${session.path}"`, { cwd: ROOT, encoding: 'utf8' });
+          execSync(`git worktree remove --force "${session.path}"`, {
+            cwd: ROOT,
+            encoding: 'utf8',
+          });
           result.worktreeDeleted = true;
         } catch (e2) {
           result.worktreeDeleted = false;
@@ -1395,7 +1648,7 @@ function getConflictingFiles(sessionId) {
   const branchSet = new Set((branchFiles.stdout || '').trim().split('\n').filter(Boolean));
 
   // Find intersection (files changed in both)
-  const conflicting = [...mainSet].filter((f) => branchSet.has(f));
+  const conflicting = [...mainSet].filter(f => branchSet.has(f));
 
   return { success: true, files: conflicting };
 }
@@ -1612,6 +1865,65 @@ function getActiveSession() {
   }
 }
 
+/**
+ * Get thread type for a session.
+ * @param {string} sessionId - Session ID (or null for current session)
+ * @returns {{ success: boolean, thread_type?: string, error?: string }}
+ */
+function getSessionThreadType(sessionId = null) {
+  const registry = loadRegistry();
+  const cwd = process.cwd();
+
+  // Find session
+  let targetId = sessionId;
+  if (!targetId) {
+    // Find current session by path
+    for (const [id, session] of Object.entries(registry.sessions)) {
+      if (session.path === cwd) {
+        targetId = id;
+        break;
+      }
+    }
+  }
+
+  if (!targetId || !registry.sessions[targetId]) {
+    return { success: false, error: 'Session not found' };
+  }
+
+  const session = registry.sessions[targetId];
+  // Return thread_type or auto-detect for legacy sessions
+  const threadType = session.thread_type || (session.is_main ? 'base' : 'parallel');
+
+  return {
+    success: true,
+    thread_type: threadType,
+    session_id: targetId,
+    is_main: session.is_main,
+  };
+}
+
+/**
+ * Update thread type for a session.
+ * @param {string} sessionId - Session ID
+ * @param {string} threadType - New thread type
+ * @returns {{ success: boolean, error?: string }}
+ */
+function setSessionThreadType(sessionId, threadType) {
+  if (!THREAD_TYPES.includes(threadType)) {
+    return { success: false, error: `Invalid thread type: ${threadType}. Valid: ${THREAD_TYPES.join(', ')}` };
+  }
+
+  const registry = loadRegistry();
+  if (!registry.sessions[sessionId]) {
+    return { success: false, error: `Session ${sessionId} not found` };
+  }
+
+  registry.sessions[sessionId].thread_type = threadType;
+  saveRegistry(registry);
+
+  return { success: true, thread_type: threadType };
+}
+
 // Export for use as module
 module.exports = {
   loadRegistry,
@@ -1639,6 +1951,15 @@ module.exports = {
   switchSession,
   clearActiveSession,
   getActiveSession,
+  // Thread type tracking
+  THREAD_TYPES,
+  detectThreadType,
+  getSessionThreadType,
+  setSessionThreadType,
+  // Kanban visualization
+  SESSION_PHASES,
+  getSessionPhase,
+  renderKanbanBoard,
 };
 
 // Run CLI if executed directly

package/scripts/test-session-boundary.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+/**
+ * test-session-boundary.js - Test session boundary hook logic
+ *
+ * Usage:
+ *   node test-session-boundary.js --active=/path/to/session --file=/path/to/file
+ *
+ * Examples:
+ *   node test-session-boundary.js --active=/home/coder/project-bugfix --file=/home/coder/project-bugfix/src/App.tsx
+ *   → ALLOWED (file is inside active session)
+ *
+ *   node test-session-boundary.js --active=/home/coder/project-bugfix --file=/home/coder/project/src/App.tsx
+ *   → BLOCKED (file is outside active session)
+ */
+
+const path = require('path');
+
+// Parse arguments
+const args = process.argv.slice(2);
+let activeSessionPath = null;
+let filePath = null;
+
+for (const arg of args) {
+  if (arg.startsWith('--active=')) {
+    activeSessionPath = arg.slice('--active='.length);
+  } else if (arg.startsWith('--file=')) {
+    filePath = arg.slice('--file='.length);
+  }
+}
+
+// Show usage if missing args
+if (!activeSessionPath || !filePath) {
+  console.log(`
+Session Boundary Hook Tester
+
+Usage:
+  node test-session-boundary.js --active=<session_path> --file=<file_path>
+
+Examples:
+  # File INSIDE active session (should be ALLOWED)
+  node test-session-boundary.js \\
+    --active=/home/coder/project-bugfix \\
+    --file=/home/coder/project-bugfix/src/App.tsx
+
+  # File OUTSIDE active session (should be BLOCKED)
+  node test-session-boundary.js \\
+    --active=/home/coder/project-bugfix \\
+    --file=/home/coder/project/src/App.tsx
+`);
+  process.exit(0);
+}
+
+// Normalize paths
+const normalizedActive = path.resolve(activeSessionPath);
+const normalizedFile = path.resolve(filePath);
+
+console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+console.log('Session Boundary Check');
+console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+
+console.log(`Active Session Path: ${normalizedActive}`);
+console.log(`File Being Edited:   ${normalizedFile}`);
+console.log('');
+
+// Check if file is within active session path
+const isInsideSession = normalizedFile.startsWith(normalizedActive + path.sep) ||
+                        normalizedFile === normalizedActive;
+
+if (isInsideSession) {
+  console.log('✅ ALLOWED - File is inside the active session directory');
+  console.log('');
+  console.log('The hook would exit(0) and allow this edit.');
+} else {
+  console.log('❌ BLOCKED - File is OUTSIDE the active session directory!');
+  console.log('');
+  console.log('The hook would exit(2) and block this edit with message:');
+  console.log(`  "Edit blocked: ${normalizedFile} is outside active session ${normalizedActive}"`);
+}
+
+console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');

package/src/core/agents/mentor.md

@@ -447,8 +447,46 @@ Before implementing, evaluate task complexity:
 3. Design implementation approach
 4. Present plan with file paths and steps
 5. Clarify decisions with user
-6. Get approval → `ExitPlanMode`
-7. Implement the approved plan
+6. **PLAN REVIEW CHECKPOINT** (see below)
+7. Get approval → `ExitPlanMode`
+8. Implement the approved plan
+
+### Plan Review Checkpoint (CRITICAL)
+
+**Before transitioning from plan → implement, ALWAYS display:**
+
+```markdown
+---
+
+## Plan Review Checkpoint
+
+**Leverage Reminder:**
+```
+Bad line of code        = 1 bad line
+Bad part of plan        = 100+ bad lines
+Bad line of research    = entire direction is hosed
+```
+
+Take time to review this plan. A few minutes now saves hours later.
+
+**Review Checklist:**
+- [ ] Does this approach make sense for the codebase?
+- [ ] Are there simpler alternatives?
+- [ ] Will this cause breaking changes?
+- [ ] Are edge cases covered?
+
+**Approve plan and proceed to implementation?**
+```
+
+**Why this matters:**
+- Plans are the highest-leverage checkpoint for human review
+- Catching a bad approach before coding saves 100s of lines of rework
+- This is where to invest review time (not code review)
+
+**Options to present:**
+1. **Approve** - Proceed to implementation
+2. **Iterate** - Modify the plan first
+3. **Research** - Need more context before deciding
 
 **Plan Quality Checklist**:
 - [ ] Explored relevant codebase