agileflow 2.85.0 → 2.86.0

package/scripts/obtain-context.js

@@ -26,8 +26,67 @@ const { isValidCommandName } = require('../lib/validate');
 // Summary table should be the LAST thing visible before truncation.
 const DISPLAY_LIMIT = 29200;
 
-// Optional: Register command for PreCompact context preservation
+// =============================================================================
+// Progressive Disclosure: Section Activation
+// =============================================================================
+
+/**
+ * Parse command-line arguments and determine which sections to activate.
+ * Sections are conditionally loaded based on parameters like MODE=loop.
+ *
+ * Section mapping:
+ *   - MODE=loop          → activates: loop-mode
+ *   - Multi-session env  → activates: multi-session
+ *   - (Other triggers detected at runtime by the agent)
+ *
+ * @param {string[]} args - Command-line arguments after command name
+ * @returns {Object} { activeSections: string[], params: Object }
+ */
+function parseCommandArgs(args) {
+  const activeSections = [];
+  const params = {};
+
+  for (const arg of args) {
+    // Parse KEY=VALUE arguments
+    const match = arg.match(/^([A-Z_]+)=(.+)$/i);
+    if (match) {
+      const [, key, value] = match;
+      params[key.toUpperCase()] = value;
+    }
+  }
+
+  // Activate sections based on parameters
+  if (params.MODE === 'loop') {
+    activeSections.push('loop-mode');
+  }
+
+  if (params.VISUAL === 'true') {
+    activeSections.push('visual-e2e');
+  }
+
+  // Check for multi-session environment
+  const registryPath = '.agileflow/sessions/registry.json';
+  if (fs.existsSync(registryPath)) {
+    try {
+      const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+      const sessionCount = Object.keys(registry.sessions || {}).length;
+      if (sessionCount > 1) {
+        activeSections.push('multi-session');
+      }
+    } catch {
+      // Silently ignore registry read errors
+    }
+  }
+
+  return { activeSections, params };
+}
+
+// Parse arguments
 const commandName = process.argv[2];
+const commandArgs = process.argv.slice(3);
+const { activeSections, params: commandParams } = parseCommandArgs(commandArgs);
+
+// Register command for PreCompact context preservation
 if (commandName && isValidCommandName(commandName)) {
   const sessionStatePath = 'docs/09-agents/session-state.json';
   if (fs.existsSync(sessionStatePath)) {
@@ -42,11 +101,13 @@ if (commandName && isValidCommandName(commandName)) {
       // Remove any existing entry for this command (avoid duplicates)
       state.active_commands = state.active_commands.filter(c => c.name !== commandName);
 
-      // Add the new command
+      // Add the new command with active sections for progressive disclosure
       state.active_commands.push({
         name: commandName,
         activated_at: new Date().toISOString(),
         state: {},
+        active_sections: activeSections,
+        params: commandParams,
       });
 
       // Remove legacy active_command field (only use active_commands array now)
@@ -262,6 +323,13 @@ function generateSummary() {
     summary += row('⭐ Up Next', readyStories.slice(0, 3).join(', '), C.skyBlue, C.skyBlue);
   }
 
+  // Progressive disclosure: Show active sections
+  if (activeSections.length > 0) {
+    summary += divider();
+    const sectionList = activeSections.join(', ');
+    summary += row('📖 Sections', sectionList, C.cyan, C.mintGreen);
+  }
+
   summary += divider();
 
   // Key files (using vibrant 256-color palette)
@@ -318,6 +386,35 @@ function generateFullContent() {
   content += `${C.lavender}${C.bold}${title}${C.reset}\n`;
   content += `${C.dim}Generated: ${new Date().toISOString()}${C.reset}\n`;
 
+  // 0. PROGRESSIVE DISCLOSURE (section activation)
+  if (activeSections.length > 0) {
+    content += `\n${C.cyan}${C.bold}═══ 📖 Progressive Disclosure: Active Sections ═══${C.reset}\n`;
+    content += `${C.dim}The following sections are activated based on command parameters.${C.reset}\n`;
+    content += `${C.dim}Look for <!-- SECTION: name --> markers in the command file.${C.reset}\n\n`;
+
+    activeSections.forEach(section => {
+      content += `  ${C.mintGreen}✓${C.reset} ${C.bold}${section}${C.reset}\n`;
+    });
+
+    // Map sections to their triggers for context
+    const sectionDescriptions = {
+      'loop-mode': 'Autonomous epic execution (MODE=loop)',
+      'multi-session': 'Multi-session coordination detected',
+      'visual-e2e': 'Visual screenshot verification (VISUAL=true)',
+      'delegation': 'Expert spawning patterns (load when spawning)',
+      'stuck': 'Research prompt guidance (load after 2 failures)',
+      'plan-mode': 'Planning workflow details (load when entering plan mode)',
+      'tools': 'Tool usage guidance (load when needed)',
+    };
+
+    content += `\n${C.dim}Section meanings:${C.reset}\n`;
+    activeSections.forEach(section => {
+      const desc = sectionDescriptions[section] || 'Conditional content';
+      content += `  ${C.dim}• ${section}: ${desc}${C.reset}\n`;
+    });
+    content += '\n';
+  }
+
   // 1. GIT STATUS (using vibrant 256-color palette)
   content += `\n${C.skyBlue}${C.bold}═══ Git Status ═══${C.reset}\n`;
   const branch = safeExec('git branch --show-current') || 'unknown';
@@ -376,6 +473,19 @@ function generateFullContent() {
       // Backwards compatibility for old format
       content += `Active command: ${C.skyBlue}${sessionState.active_command.name}${C.reset}\n`;
     }
+
+    // Show batch loop status if active
+    const batchLoop = sessionState.batch_loop;
+    if (batchLoop && batchLoop.enabled) {
+      content += `\n${C.skyBlue}${C.bold}── Batch Loop Active ──${C.reset}\n`;
+      content += `Pattern: ${C.cyan}${batchLoop.pattern}${C.reset}\n`;
+      content += `Action: ${C.cyan}${batchLoop.action}${C.reset}\n`;
+      content += `Current: ${C.lightYellow}${batchLoop.current_item || 'none'}${C.reset}\n`;
+      const summary = batchLoop.summary || {};
+      content += `Progress: ${C.lightGreen}${summary.completed || 0}${C.reset}/${summary.total || 0} `;
+      content += `(${C.lightYellow}${summary.in_progress || 0}${C.reset} in progress)\n`;
+      content += `Iteration: ${batchLoop.iteration || 0}/${batchLoop.max_iterations || 50}\n`;
+    }
   } else {
     content += `${C.dim}No session-state.json found${C.reset}\n`;
   }
@@ -440,9 +550,7 @@ function generateFullContent() {
 
   if (fs.existsSync(storyClaimingPath) || fs.existsSync(altStoryClaimingPath)) {
     try {
-      const claimPath = fs.existsSync(storyClaimingPath)
-        ? storyClaimingPath
-        : altStoryClaimingPath;
+      const claimPath = fs.existsSync(storyClaimingPath) ? storyClaimingPath : altStoryClaimingPath;
       const storyClaiming = require(claimPath);
 
       // Get stories claimed by other sessions
@@ -451,7 +559,9 @@ function generateFullContent() {
         content += `\n${C.amber}${C.bold}═══ 🔒 Claimed Stories ═══${C.reset}\n`;
         content += `${C.dim}Stories locked by other sessions - pick a different one${C.reset}\n`;
         othersResult.stories.forEach(story => {
-          const sessionDir = story.claimedBy?.path ? path.basename(story.claimedBy.path) : 'unknown';
+          const sessionDir = story.claimedBy?.path
+            ? path.basename(story.claimedBy.path)
+            : 'unknown';
           content += `  ${C.coral}🔒${C.reset} ${C.lavender}${story.id}${C.reset} "${story.title}" ${C.dim}→ Session ${story.claimedBy?.session_id || '?'} (${sessionDir})${C.reset}\n`;
         });
         content += '\n';
@@ -477,9 +587,7 @@ function generateFullContent() {
 
   if (fs.existsSync(fileTrackingPath) || fs.existsSync(altFileTrackingPath)) {
     try {
-      const trackPath = fs.existsSync(fileTrackingPath)
-        ? fileTrackingPath
-        : altFileTrackingPath;
+      const trackPath = fs.existsSync(fileTrackingPath) ? fileTrackingPath : altFileTrackingPath;
       const fileTracking = require(trackPath);
 
       // Get file overlaps with other sessions
@@ -488,10 +596,12 @@ function generateFullContent() {
         content += `\n${C.amber}${C.bold}═══ ⚠️  File Overlaps ═══${C.reset}\n`;
         content += `${C.dim}Files also edited by other sessions - conflicts auto-resolved during merge${C.reset}\n`;
         overlapsResult.overlaps.forEach(overlap => {
-          const sessionInfo = overlap.otherSessions.map(s => {
-            const dir = path.basename(s.path);
-            return `Session ${s.id} (${dir})`;
-          }).join(', ');
+          const sessionInfo = overlap.otherSessions
+            .map(s => {
+              const dir = path.basename(s.path);
+              return `Session ${s.id} (${dir})`;
+            })
+            .join(', ');
           content += `  ${C.amber}⚠${C.reset} ${C.lavender}${overlap.file}${C.reset} ${C.dim}→ ${sessionInfo}${C.reset}\n`;
         });
         content += '\n';
@@ -524,7 +634,8 @@ function generateFullContent() {
   // 6. VISUAL E2E STATUS (detect from metadata or filesystem)
   const metadata = safeReadJSON('docs/00-meta/agileflow-metadata.json');
   const visualE2eConfig = metadata?.features?.visual_e2e;
-  const playwrightExists = fs.existsSync('playwright.config.ts') || fs.existsSync('playwright.config.js');
+  const playwrightExists =
+    fs.existsSync('playwright.config.ts') || fs.existsSync('playwright.config.js');
   const screenshotsExists = fs.existsSync('screenshots');
   const testsE2eExists = fs.existsSync('tests/e2e');
 

package/scripts/session-boundary.js

@@ -61,8 +61,9 @@ function isInsideSession(filePath, sessionPath) {
   const normalizedFile = path.resolve(filePath);
   const normalizedSession = path.resolve(sessionPath);
 
-  return normalizedFile.startsWith(normalizedSession + path.sep) ||
-         normalizedFile === normalizedSession;
+  return (
+    normalizedFile.startsWith(normalizedSession + path.sep) || normalizedFile === normalizedSession
+  );
 }
 
 // Output blocked message
@@ -117,7 +118,6 @@ function main() {
       // File is OUTSIDE active session - BLOCK
       outputBlocked(filePath, activeSession);
       process.exit(2);
-
     } catch (e) {
       // Parse error or other issue - fail open
       process.exit(0);

package/scripts/session-manager.js

@@ -156,8 +156,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 +192,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 +207,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 +219,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 +314,7 @@ function createSession(options = {}) {
     };
   }
 
-  // Register session
+  // Register session - worktree sessions are always parallel threads
   registry.next_id++;
   registry.sessions[sessionId] = {
     path: worktreePath,
@@ -301,6 +324,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 +334,7 @@ function createSession(options = {}) {
     sessionId,
     path: worktreePath,
     branch: branchName,
+    thread_type: registry.sessions[sessionId].thread_type,
     command: `cd "${worktreePath}" && claude`,
   };
 }
@@ -671,6 +696,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 +938,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) {
@@ -814,11 +1010,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 +1027,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;
@@ -984,6 +1186,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 +1223,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 +1410,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 +1519,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 +1622,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 +1839,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 +1925,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