claude-code-workflow 6.3.37 → 6.3.39

package/ccw/src/core/routes/issue-routes.ts

@@ -212,20 +212,22 @@ function getIssueDetail(issuesDir: string, issueId: string) {
 function enrichIssues(issues: any[], issuesDir: string) {
   return issues.map(issue => {
     const solutions = readSolutionsJsonl(issuesDir, issue.id);
-    let taskCount = 0;
+    let tasks: any[] = [];
 
-    // Get task count from bound solution
+    // Get tasks from bound solution
     if (issue.bound_solution_id) {
       const boundSol = solutions.find(s => s.id === issue.bound_solution_id);
       if (boundSol?.tasks) {
-        taskCount = boundSol.tasks.length;
+        tasks = boundSol.tasks;
       }
     }
 
     return {
       ...issue,
+      solutions,                        // Add full solutions array
+      tasks,                            // Add full tasks array
       solution_count: solutions.length,
-      task_count: taskCount
+      task_count: tasks.length
     };
   });
 }
@@ -337,41 +339,58 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
 
   const issuesDir = join(projectPath, '.workflow', 'issues');
 
-  // ===== Queue Routes (top-level /api/queue) =====
+  // ===== Helper: Normalize queue path (supports both /api/queue/* and /api/issues/queue/*) =====
+  const normalizeQueuePath = (path: string): string | null => {
+    if (path.startsWith('/api/issues/queue')) {
+      return path.replace('/api/issues/queue', '/api/queue');
+    }
+    if (path.startsWith('/api/queue')) {
+      return path;
+    }
+    return null;
+  };
 
-  // GET /api/queue - Get execution queue
-  if (pathname === '/api/queue' && req.method === 'GET') {
+  const normalizedPath = normalizeQueuePath(pathname);
+
+  // ===== Queue Routes (supports both /api/queue/* and /api/issues/queue/*) =====
+
+  // GET /api/queue or /api/issues/queue - Get execution queue
+  if ((normalizedPath === '/api/queue') && req.method === 'GET') {
     const queue = groupQueueByExecutionGroup(readQueue(issuesDir));
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(queue));
     return true;
   }
 
-  // GET /api/queue/history - Get queue history (all queues from index)
-  if (pathname === '/api/queue/history' && req.method === 'GET') {
+  // GET /api/queue/history or /api/issues/queue/history - Get queue history (all queues from index)
+  if (normalizedPath === '/api/queue/history' && req.method === 'GET') {
     const queuesDir = join(issuesDir, 'queues');
     const indexPath = join(queuesDir, 'index.json');
 
     if (!existsSync(indexPath)) {
       res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ queues: [], active_queue_id: null }));
+      res.end(JSON.stringify({ queues: [], active_queue_id: null, active_queue_ids: [] }));
       return true;
     }
 
     try {
       const index = JSON.parse(readFileSync(indexPath, 'utf8'));
+      // Ensure active_queue_ids is always returned for multi-queue support
+      if (!index.active_queue_ids) {
+        index.active_queue_ids = index.active_queue_id ? [index.active_queue_id] : [];
+      }
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify(index));
     } catch {
       res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ queues: [], active_queue_id: null }));
+      res.end(JSON.stringify({ queues: [], active_queue_id: null, active_queue_ids: [] }));
     }
     return true;
   }
 
-  // GET /api/queue/:id - Get specific queue by ID
-  const queueDetailMatch = pathname.match(/^\/api\/queue\/([^/]+)$/);
-  const reservedQueuePaths = ['history', 'reorder', 'switch', 'deactivate', 'merge'];
+  // GET /api/queue/:id or /api/issues/queue/:id - Get specific queue by ID
+  const queueDetailMatch = normalizedPath?.match(/^\/api\/queue\/([^/]+)$/);
+  const reservedQueuePaths = ['history', 'reorder', 'switch', 'deactivate', 'merge', 'activate'];
   if (queueDetailMatch && req.method === 'GET' && !reservedQueuePaths.includes(queueDetailMatch[1])) {
     const queueId = queueDetailMatch[1];
     const queuesDir = join(issuesDir, 'queues');
@@ -394,8 +413,55 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
     return true;
   }
 
-  // POST /api/queue/switch - Switch active queue
-  if (pathname === '/api/queue/switch' && req.method === 'POST') {
+  // POST /api/queue/activate or /api/issues/queue/activate - Activate one or more queues (multi-queue support)
+  if (normalizedPath === '/api/queue/activate' && req.method === 'POST') {
+    handlePostRequest(req, res, async (body: any) => {
+      const { queueId, queueIds } = body;
+
+      // Support both single queueId and array queueIds
+      const idsToActivate: string[] = queueIds
+        ? (Array.isArray(queueIds) ? queueIds : [queueIds])
+        : (queueId ? [queueId] : []);
+
+      if (idsToActivate.length === 0) {
+        return { error: 'queueId or queueIds required' };
+      }
+
+      const queuesDir = join(issuesDir, 'queues');
+      const indexPath = join(queuesDir, 'index.json');
+
+      // Validate all queue IDs exist
+      for (const id of idsToActivate) {
+        const queueFilePath = join(queuesDir, `${id}.json`);
+        if (!existsSync(queueFilePath)) {
+          return { error: `Queue ${id} not found` };
+        }
+      }
+
+      try {
+        const index = existsSync(indexPath)
+          ? JSON.parse(readFileSync(indexPath, 'utf8'))
+          : { active_queue_id: null, active_queue_ids: [], queues: [] };
+
+        index.active_queue_ids = idsToActivate;
+        index.active_queue_id = idsToActivate[0] || null; // Backward compat
+
+        writeFileSync(indexPath, JSON.stringify(index, null, 2));
+
+        return {
+          success: true,
+          active_queue_ids: idsToActivate,
+          active_queue_id: idsToActivate[0] || null // Backward compat
+        };
+      } catch (err) {
+        return { error: 'Failed to activate queue(s)' };
+      }
+    });
+    return true;
+  }
+
+  // POST /api/queue/switch or /api/issues/queue/switch - Switch active queue (legacy, single queue)
+  if (normalizedPath === '/api/queue/switch' && req.method === 'POST') {
     handlePostRequest(req, res, async (body: any) => {
       const { queueId } = body;
       if (!queueId) return { error: 'queueId required' };
@@ -411,12 +477,18 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
       try {
         const index = existsSync(indexPath)
           ? JSON.parse(readFileSync(indexPath, 'utf8'))
-          : { active_queue_id: null, queues: [] };
+          : { active_queue_id: null, active_queue_ids: [], queues: [] };
 
         index.active_queue_id = queueId;
+        index.active_queue_ids = [queueId]; // Also update multi-queue array
+
         writeFileSync(indexPath, JSON.stringify(index, null, 2));
 
-        return { success: true, active_queue_id: queueId };
+        return {
+          success: true,
+          active_queue_id: queueId,
+          active_queue_ids: [queueId]
+        };
       } catch (err) {
         return { error: 'Failed to switch queue' };
       }
@@ -424,22 +496,43 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
     return true;
   }
 
-  // POST /api/queue/deactivate - Deactivate current queue (set active to null)
-  if (pathname === '/api/queue/deactivate' && req.method === 'POST') {
+  // POST /api/queue/deactivate or /api/issues/queue/deactivate - Deactivate queue(s)
+  if (normalizedPath === '/api/queue/deactivate' && req.method === 'POST') {
     handlePostRequest(req, res, async (body: any) => {
+      const { queueId } = body; // Optional: specific queue to deactivate
       const queuesDir = join(issuesDir, 'queues');
       const indexPath = join(queuesDir, 'index.json');
 
       try {
         const index = existsSync(indexPath)
           ? JSON.parse(readFileSync(indexPath, 'utf8'))
-          : { active_queue_id: null, queues: [] };
+          : { active_queue_id: null, active_queue_ids: [], queues: [] };
+
+        const currentActiveIds = index.active_queue_ids || (index.active_queue_id ? [index.active_queue_id] : []);
+        let deactivatedIds: string[] = [];
+        let remainingIds: string[] = [];
+
+        if (queueId) {
+          // Deactivate specific queue
+          deactivatedIds = currentActiveIds.includes(queueId) ? [queueId] : [];
+          remainingIds = currentActiveIds.filter((id: string) => id !== queueId);
+        } else {
+          // Deactivate all
+          deactivatedIds = [...currentActiveIds];
+          remainingIds = [];
+        }
+
+        index.active_queue_ids = remainingIds;
+        index.active_queue_id = remainingIds[0] || null; // Backward compat
 
-        const previousActiveId = index.active_queue_id;
-        index.active_queue_id = null;
         writeFileSync(indexPath, JSON.stringify(index, null, 2));
 
-        return { success: true, previous_active_id: previousActiveId };
+        return {
+          success: true,
+          deactivated_queue_ids: deactivatedIds,
+          active_queue_ids: remainingIds,
+          active_queue_id: remainingIds[0] || null // Backward compat
+        };
       } catch (err) {
         return { error: 'Failed to deactivate queue' };
       }
@@ -447,8 +540,8 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
     return true;
   }
 
-  // POST /api/queue/reorder - Reorder queue items (supports both solutions and tasks)
-  if (pathname === '/api/queue/reorder' && req.method === 'POST') {
+  // POST /api/queue/reorder or /api/issues/queue/reorder - Reorder queue items (supports both solutions and tasks)
+  if (normalizedPath === '/api/queue/reorder' && req.method === 'POST') {
     handlePostRequest(req, res, async (body: any) => {
       const { groupId, newOrder } = body;
       if (!groupId || !Array.isArray(newOrder)) {
@@ -499,8 +592,8 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
     return true;
   }
 
-  // DELETE /api/queue/:queueId/item/:itemId - Delete item from queue
-  const queueItemDeleteMatch = pathname.match(/^\/api\/queue\/([^/]+)\/item\/([^/]+)$/);
+  // DELETE /api/queue/:queueId/item/:itemId or /api/issues/queue/:queueId/item/:itemId
+  const queueItemDeleteMatch = normalizedPath?.match(/^\/api\/queue\/([^/]+)\/item\/([^/]+)$/);
   if (queueItemDeleteMatch && req.method === 'DELETE') {
     const queueId = queueItemDeleteMatch[1];
     const itemId = decodeURIComponent(queueItemDeleteMatch[2]);
@@ -574,8 +667,8 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
     return true;
   }
 
-  // DELETE /api/queue/:queueId - Delete entire queue
-  const queueDeleteMatch = pathname.match(/^\/api\/queue\/([^/]+)$/);
+  // DELETE /api/queue/:queueId or /api/issues/queue/:queueId - Delete entire queue
+  const queueDeleteMatch = normalizedPath?.match(/^\/api\/queue\/([^/]+)$/);
   if (queueDeleteMatch && req.method === 'DELETE') {
     const queueId = queueDeleteMatch[1];
     const queuesDir = join(issuesDir, 'queues');
@@ -616,8 +709,8 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
     return true;
   }
 
-  // POST /api/queue/merge - Merge source queue into target queue
-  if (pathname === '/api/queue/merge' && req.method === 'POST') {
+  // POST /api/queue/merge or /api/issues/queue/merge - Merge source queue into target queue
+  if (normalizedPath === '/api/queue/merge' && req.method === 'POST') {
     handlePostRequest(req, res, async (body: any) => {
       const { sourceQueueId, targetQueueId } = body;
       if (!sourceQueueId || !targetQueueId) {
@@ -755,7 +848,7 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
   }
 
   // POST /api/queue/split - Split items from source queue into a new queue
-  if (pathname === '/api/queue/split' && req.method === 'POST') {
+  if (normalizedPath === '/api/queue/split' && req.method === 'POST') {
     handlePostRequest(req, res, async (body: any) => {
       const { sourceQueueId, itemIds } = body;
       if (!sourceQueueId || !itemIds || !Array.isArray(itemIds) || itemIds.length === 0) {
@@ -992,6 +1085,188 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
     return true;
   }
 
+  // POST /api/issues/pull - Pull issues from GitHub
+  if (pathname === '/api/issues/pull' && req.method === 'POST') {
+    const state = url.searchParams.get('state') || 'open';
+    const limit = parseInt(url.searchParams.get('limit') || '100');
+    const labels = url.searchParams.get('labels') || '';
+    const downloadImages = url.searchParams.get('downloadImages') === 'true';
+
+    try {
+      const { execSync } = await import('child_process');
+      const https = await import('https');
+      const http = await import('http');
+
+      // Check if gh CLI is available
+      try {
+        execSync('gh --version', { stdio: 'ignore', timeout: 5000 });
+      } catch {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'GitHub CLI (gh) is not installed or not in PATH' }));
+        return true;
+      }
+
+      // Build gh command
+      let ghCommand = `gh issue list --state ${state} --limit ${limit} --json number,title,body,labels,url,state`;
+      if (labels) ghCommand += ` --label "${labels}"`;
+
+      // Execute gh command from project root
+      const ghOutput = execSync(ghCommand, {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 60000,
+        cwd: issuesDir.replace(/[\\/]\.workflow[\\/]issues$/, '')
+      }).trim();
+
+      if (!ghOutput) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ imported: 0, updated: 0, skipped: 0, images_downloaded: 0 }));
+        return true;
+      }
+
+      const ghIssues = JSON.parse(ghOutput);
+      const existingIssues = readIssuesJsonl(issuesDir);
+
+      let imported = 0;
+      let skipped = 0;
+      let updated = 0;
+      let imagesDownloaded = 0;
+
+      // Create images directory if needed
+      const imagesDir = join(issuesDir, 'images');
+      if (downloadImages && !existsSync(imagesDir)) {
+        mkdirSync(imagesDir, { recursive: true });
+      }
+
+      // Helper function to download image
+      const downloadImage = async (imageUrl: string, issueNumber: number, imageIndex: number): Promise<string | null> => {
+        return new Promise((resolveDownload) => {
+          try {
+            const ext = imageUrl.match(/\.(png|jpg|jpeg|gif|webp|svg)/i)?.[1] || 'png';
+            const filename = `GH-${issueNumber}-${imageIndex}.${ext}`;
+            const filePath = join(imagesDir, filename);
+
+            // Skip if already downloaded
+            if (existsSync(filePath)) {
+              resolveDownload(`.workflow/issues/images/${filename}`);
+              return;
+            }
+
+            const protocol = imageUrl.startsWith('https') ? https : http;
+            protocol.get(imageUrl, { timeout: 30000 }, (response: any) => {
+              // Handle redirect
+              if (response.statusCode === 301 || response.statusCode === 302) {
+                const redirectUrl = response.headers.location;
+                if (redirectUrl) {
+                  downloadImage(redirectUrl, issueNumber, imageIndex).then(resolveDownload);
+                  return;
+                }
+              }
+              if (response.statusCode !== 200) {
+                resolveDownload(null);
+                return;
+              }
+
+              const chunks: Buffer[] = [];
+              response.on('data', (chunk: Buffer) => chunks.push(chunk));
+              response.on('end', () => {
+                try {
+                  writeFileSync(filePath, Buffer.concat(chunks));
+                  resolveDownload(`.workflow/issues/images/${filename}`);
+                } catch {
+                  resolveDownload(null);
+                }
+              });
+              response.on('error', () => resolveDownload(null));
+            }).on('error', () => resolveDownload(null));
+          } catch {
+            resolveDownload(null);
+          }
+        });
+      };
+
+      // Process issues
+      for (const ghIssue of ghIssues) {
+        const issueId = `GH-${ghIssue.number}`;
+        const existingIssue = existingIssues.find((i: any) => i.id === issueId);
+
+        let context = ghIssue.body || ghIssue.title;
+
+        // Extract and download images if enabled
+        if (downloadImages && ghIssue.body) {
+          // Find all image URLs in the body
+          const imgPattern = /!\[[^\]]*\]\((https?:\/\/[^)]+)\)|<img[^>]+src=["'](https?:\/\/[^"']+)["']/gi;
+          const imageUrls: string[] = [];
+          let match;
+          while ((match = imgPattern.exec(ghIssue.body)) !== null) {
+            imageUrls.push(match[1] || match[2]);
+          }
+
+          // Download images and build reference list
+          if (imageUrls.length > 0) {
+            const downloadedImages: string[] = [];
+            for (let i = 0; i < imageUrls.length; i++) {
+              const localPath = await downloadImage(imageUrls[i], ghIssue.number, i + 1);
+              if (localPath) {
+                downloadedImages.push(localPath);
+                imagesDownloaded++;
+              }
+            }
+
+            // Append image references to context
+            if (downloadedImages.length > 0) {
+              context += '\n\n---\n**Downloaded Images:**\n';
+              downloadedImages.forEach((path, idx) => {
+                context += `- Image ${idx + 1}: \`${path}\`\n`;
+              });
+            }
+          }
+        }
+
+        // Prepare issue data (truncate context to 2000 chars max)
+        const issueData = {
+          id: issueId,
+          title: ghIssue.title,
+          status: ghIssue.state === 'OPEN' ? 'registered' : 'completed',
+          priority: 3,
+          context: context.substring(0, 2000),
+          source: 'github',
+          source_url: ghIssue.url,
+          tags: ghIssue.labels?.map((l: any) => l.name) || [],
+          created_at: new Date().toISOString(),
+          updated_at: new Date().toISOString()
+        };
+
+        if (existingIssue) {
+          // Update if changed
+          const newStatus = ghIssue.state === 'OPEN' ? 'registered' : 'completed';
+          if (existingIssue.status !== newStatus || existingIssue.title !== ghIssue.title) {
+            existingIssue.title = ghIssue.title;
+            existingIssue.status = newStatus;
+            existingIssue.context = issueData.context;
+            existingIssue.updated_at = new Date().toISOString();
+            updated++;
+          } else {
+            skipped++;
+          }
+        } else {
+          existingIssues.push(issueData);
+          imported++;
+        }
+      }
+
+      // Save all issues
+      writeIssuesJsonl(issuesDir, existingIssues);
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ imported, updated, skipped, images_downloaded: imagesDownloaded, total: ghIssues.length }));
+    } catch (err: any) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: err.message || 'Failed to pull issues from GitHub' }));
+    }
+    return true;
+  }
+
   // GET /api/issues/:id - Get issue detail
   const detailMatch = pathname.match(/^\/api\/issues\/([^/]+)$/);
   if (detailMatch && req.method === 'GET') {

package/ccw/src/core/routes/loop-v2-routes.ts

@@ -29,11 +29,45 @@
 
 import { join } from 'path';
 import { randomBytes } from 'crypto';
+import * as os from 'os';
 import type { RouteContext } from './types.js';
 import { LoopStatus } from '../../types/loop.js';
 import type { LoopState } from '../../types/loop.js';
 import { TaskStorageManager, type TaskCreateRequest, type TaskUpdateRequest, type TaskReorderRequest } from '../../tools/loop-task-manager.js';
 import { executeCliTool } from '../../tools/cli-executor.js';
+import { loadClaudeCliTools } from '../../tools/claude-cli-tools.js';
+
+/**
+ * Module-level cache for CLI tools configuration
+ * Loaded once at server startup to avoid repeated file I/O
+ */
+let cachedEnabledTools: string[] | null = null;
+
+/**
+ * Initialize CLI tools cache at server startup
+ * Should be called once when the server starts
+ */
+export function initializeCliToolsCache(): void {
+  try {
+    const cliToolsConfig = loadClaudeCliTools(os.homedir());
+    const enabledTools = Object.entries(cliToolsConfig.tools || {})
+      .filter(([_, config]) => config.enabled === true)
+      .map(([name]) => name);
+    cachedEnabledTools = ['bash', ...enabledTools];
+    console.log('[Loop V2] CLI tools cache initialized:', cachedEnabledTools);
+  } catch (err) {
+    console.error('[Loop V2] Failed to initialize CLI tools cache:', err);
+    // Fallback to basic tools if config loading fails
+    cachedEnabledTools = ['bash', 'gemini', 'qwen', 'codex', 'claude'];
+  }
+}
+
+/**
+ * Clear CLI tools cache (for testing or config reload)
+ */
+export function clearCliToolsCache(): void {
+  cachedEnabledTools = null;
+}
 
 /**
  * V2 Loop Create Request
@@ -710,9 +744,17 @@ export async function handleLoopV2Routes(ctx: RouteContext): Promise<boolean> {
         return { success: false, error: 'tool is required', status: 400 };
       }
 
-      const validTools = ['bash', 'gemini', 'codex', 'qwen', 'claude'];
+      // Get enabled tools from cli-tools.json dynamically
+      const cliToolsConfig = loadClaudeCliTools(os.homedir());
+      const enabledTools = Object.entries(cliToolsConfig.tools || {})
+        .filter(([_, config]) => config.enabled === true)
+        .map(([name]) => name);
+
+      // Also allow 'bash' as a special case (built-in tool)
+      const validTools = ['bash', ...enabledTools];
+
       if (!validTools.includes(tool)) {
-        return { success: false, error: `tool must be one of: ${validTools.join(', ')}`, status: 400 };
+        return { success: false, error: `tool must be one of enabled tools: ${validTools.join(', ')}`, status: 400 };
       }
 
       if (!mode || typeof mode !== 'string') {
@@ -1303,12 +1345,28 @@ function isValidId(id: string): boolean {
   return true;
 }
 
+/**
+ * Get enabled tools list from cache
+ * If cache is not initialized, it will load from config (fallback for lazy initialization)
+ */
+function getEnabledToolsList(): string[] {
+  // Return cached value if available
+  if (cachedEnabledTools) {
+    return cachedEnabledTools;
+  }
+
+  // Fallback: lazy initialization if cache not initialized (shouldn't happen in normal operation)
+  console.warn('[Loop V2] CLI tools cache not initialized, performing lazy load');
+  initializeCliToolsCache();
+  return cachedEnabledTools || ['bash', 'gemini', 'qwen', 'codex', 'claude'];
+}
+
 /**
  * Map issue tool to loop tool
  */
-function mapIssueToolToLoopTool(tool: any): 'bash' | 'gemini' | 'codex' | 'qwen' | 'claude' | null {
-  const validTools = ['bash', 'gemini', 'codex', 'qwen', 'claude'];
-  if (validTools.includes(tool)) return tool as any;
+function mapIssueToolToLoopTool(tool: any): string | null {
+  const validTools = getEnabledToolsList();
+  if (validTools.includes(tool)) return tool;
   // Map aliases
   if (tool === 'ccw') return 'gemini';
   if (tool === 'ai') return 'gemini';
@@ -1343,7 +1401,7 @@ function mapIssueOnError(onError: any): 'continue' | 'pause' | 'fail_fast' | und
  * Validate tool value
  */
 function validateTool(tool: any): boolean {
-  const validTools = ['bash', 'gemini', 'codex', 'qwen', 'claude'];
+  const validTools = getEnabledToolsList();
   return validTools.includes(tool);
 }
 

package/ccw/src/core/routes/system-routes.ts

@@ -145,7 +145,7 @@ async function getWorkflowData(projectPath: string): Promise<any> {
       generatedAt: new Date().toISOString(),
       activeSessions: [],
       archivedSessions: [],
-      liteTasks: { litePlan: [], liteFix: [] },
+      liteTasks: { litePlan: [], liteFix: [], multiCliPlan: [] },
       reviewData: { dimensions: {} },
       projectOverview: null,
       statistics: {
@@ -155,7 +155,8 @@ async function getWorkflowData(projectPath: string): Promise<any> {
         completedTasks: 0,
         reviewFindings: 0,
         litePlanCount: 0,
-        liteFixCount: 0
+        liteFixCount: 0,
+        multiCliPlanCount: 0
       },
       projectPath: normalizePathForDisplay(resolvedPath),
       recentPaths: getRecentPaths()

package/ccw/src/core/server.ts

@@ -29,7 +29,7 @@ import { handleLiteLLMApiRoutes } from './routes/litellm-api-routes.js';
 import { handleNavStatusRoutes } from './routes/nav-status-routes.js';
 import { handleAuthRoutes } from './routes/auth-routes.js';
 import { handleLoopRoutes } from './routes/loop-routes.js';
-import { handleLoopV2Routes } from './routes/loop-v2-routes.js';
+import { handleLoopV2Routes, initializeCliToolsCache } from './routes/loop-v2-routes.js';
 import { handleTestLoopRoutes } from './routes/test-loop-routes.js';
 import { handleTaskRoutes } from './routes/task-routes.js';
 
@@ -383,10 +383,10 @@ function generateServerDashboard(initialPath: string): string {
     generatedAt: new Date().toISOString(),
     activeSessions: [],
     archivedSessions: [],
-    liteTasks: { litePlan: [], liteFix: [] },
+    liteTasks: { litePlan: [], liteFix: [], multiCliPlan: [] },
     reviewData: { dimensions: {} },
     projectOverview: null,
-    statistics: { totalSessions: 0, activeSessions: 0, totalTasks: 0, completedTasks: 0, reviewFindings: 0, litePlanCount: 0, liteFixCount: 0 }
+    statistics: { totalSessions: 0, activeSessions: 0, totalTasks: 0, completedTasks: 0, reviewFindings: 0, litePlanCount: 0, liteFixCount: 0, multiCliPlanCount: 0 }
   };
 
   // Replace JS placeholders
@@ -723,6 +723,9 @@ export async function startServer(options: ServerOptions = {}): Promise<http.Ser
       console.log(`WebSocket endpoint available at ws://${host}:${serverPort}/ws`);
       console.log(`Hook endpoint available at POST http://${host}:${serverPort}/api/hook`);
 
+      // Initialize CLI tools cache for Loop V2 routes
+      initializeCliToolsCache();
+
       // Start periodic cleanup of stale CLI executions (every 2 minutes)
       const CLEANUP_INTERVAL_MS = 2 * 60 * 1000;
       const cleanupInterval = setInterval(cleanupStaleExecutions, CLEANUP_INTERVAL_MS);

package/ccw/src/templates/dashboard-css/02-session.css

@@ -464,6 +464,7 @@
   display: flex;
   flex-direction: column;
   gap: 1rem;
+  align-items: flex-start;
 }
 
 .btn-back {
@@ -492,6 +493,7 @@
 .detail-title-row {
   display: flex;
   align-items: center;
+  justify-content: flex-start;
   gap: 1rem;
   flex-wrap: wrap;
 }