claude-code-workflow 6.3.27 → 6.3.29

package/ccw/src/core/data-aggregator.ts

@@ -77,6 +77,7 @@ interface DashboardData {
   liteTasks: {
     litePlan: unknown[];
     liteFix: unknown[];
+    multiCliPlan: unknown[];
   };
   reviewData: ReviewData | null;
   projectOverview: ProjectOverview | null;
@@ -88,6 +89,7 @@ interface DashboardData {
     reviewFindings: number;
     litePlanCount: number;
     liteFixCount: number;
+    multiCliPlanCount: number;
   };
 }
 
@@ -211,7 +213,8 @@ export async function aggregateData(sessions: ScanSessionsResult, workflowDir: s
     archivedSessions: [],
     liteTasks: {
       litePlan: [],
-      liteFix: []
+      liteFix: [],
+      multiCliPlan: []
     },
     reviewData: null,
     projectOverview: null,
@@ -222,7 +225,8 @@ export async function aggregateData(sessions: ScanSessionsResult, workflowDir: s
       completedTasks: 0,
       reviewFindings: 0,
       litePlanCount: 0,
-      liteFixCount: 0
+      liteFixCount: 0,
+      multiCliPlanCount: 0
     }
   };
 
@@ -257,6 +261,7 @@ export async function aggregateData(sessions: ScanSessionsResult, workflowDir: s
     data.liteTasks = liteTasks;
     data.statistics.litePlanCount = liteTasks.litePlan.length;
     data.statistics.liteFixCount = liteTasks.liteFix.length;
+    data.statistics.multiCliPlanCount = liteTasks.multiCliPlan.length;
   } catch (err) {
     console.error('Error scanning lite tasks:', (err as Error).message);
   }

package/ccw/src/core/lite-scanner.ts

@@ -60,9 +60,47 @@ interface LiteSession {
   progress: Progress;
 }
 
+// Multi-CLI specific session state from session-state.json
+interface MultiCliSessionState {
+  session_id: string;
+  task_description: string;
+  status: string;
+  current_phase: number;
+  phases: Record<string, { status: string; rounds_completed?: number }>;
+  ace_context?: { relevant_files: string[]; detected_patterns: string[] };
+  user_decisions?: Array<{ round: number; decision: string; selected: string }>;
+  updated_at?: string;
+}
+
+// Discussion topic structure for frontend rendering
+interface DiscussionTopic {
+  title: string;
+  description: string;
+  scope: { included: string[]; excluded: string[] };
+  keyQuestions: string[];
+  status: string;
+  tags: string[];
+}
+
+// Extended session interface for multi-cli-plan
+interface MultiCliSession extends LiteSession {
+  roundCount: number;
+  topicTitle: string;
+  status: string;
+  metadata: {
+    roundId: number;
+    timestamp: string;
+    currentPhase: number;
+  };
+  discussionTopic: DiscussionTopic;
+  rounds: RoundSynthesis[];
+  latestSynthesis: RoundSynthesis | null;
+}
+
 interface LiteTasks {
   litePlan: LiteSession[];
   liteFix: LiteSession[];
+  multiCliPlan: LiteSession[];
 }
 
 interface LiteTaskDetail {
@@ -84,13 +122,15 @@ interface LiteTaskDetail {
 export async function scanLiteTasks(workflowDir: string): Promise<LiteTasks> {
   const litePlanDir = join(workflowDir, '.lite-plan');
   const liteFixDir = join(workflowDir, '.lite-fix');
+  const multiCliDir = join(workflowDir, '.multi-cli-plan');
 
-  const [litePlan, liteFix] = await Promise.all([
+  const [litePlan, liteFix, multiCliPlan] = await Promise.all([
     scanLiteDir(litePlanDir, 'lite-plan'),
     scanLiteDir(liteFixDir, 'lite-fix'),
+    scanMultiCliDir(multiCliDir),
   ]);
 
-  return { litePlan, liteFix };
+  return { litePlan, liteFix, multiCliPlan };
 }
 
 /**
@@ -142,6 +182,427 @@ async function scanLiteDir(dir: string, type: string): Promise<LiteSession[]> {
   }
 }
 
+/**
+ * Load session-state.json from multi-cli session directory
+ * @param sessionPath - Session directory path
+ * @returns Session state or null if not found
+ */
+async function loadSessionState(sessionPath: string): Promise<MultiCliSessionState | null> {
+  const statePath = join(sessionPath, 'session-state.json');
+  try {
+    const content = await readFile(statePath, 'utf8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build discussion topic structure from session state and synthesis
+ * @param state - Session state from session-state.json
+ * @param synthesis - Latest round synthesis
+ * @returns Discussion topic for frontend rendering
+ */
+function buildDiscussionTopic(
+  state: MultiCliSessionState | null,
+  synthesis: RoundSynthesis | null
+): DiscussionTopic {
+  const keyQuestions = synthesis?.clarification_questions || [];
+  const solutions = synthesis?.solutions || [];
+
+  return {
+    title: state?.task_description || 'Discussion Topic',
+    description: solutions[0]?.summary || '',
+    scope: {
+      included: state?.ace_context?.relevant_files || [],
+      excluded: [],
+    },
+    keyQuestions,
+    status: state?.status || 'analyzing',
+    tags: solutions.map((s) => s.name).slice(0, 3),
+  };
+}
+
+/**
+ * Scan multi-cli-plan directory for sessions
+ * @param dir - Directory path to .multi-cli-plan
+ * @returns Array of multi-cli sessions with extended metadata
+ */
+async function scanMultiCliDir(dir: string): Promise<MultiCliSession[]> {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+
+    const sessions = (await Promise.all(
+      entries
+        .filter((entry) => entry.isDirectory())
+        .map(async (entry) => {
+          const sessionPath = join(dir, entry.name);
+
+          const [createdAt, syntheses, sessionState, planJson] = await Promise.all([
+            getCreatedTime(sessionPath),
+            loadRoundSyntheses(sessionPath),
+            loadSessionState(sessionPath),
+            loadPlanJson(sessionPath),
+          ]);
+
+          // Extract data from syntheses
+          const roundCount = syntheses.length;
+          const latestSynthesis = syntheses.length > 0 ? syntheses[syntheses.length - 1] : null;
+
+          // Calculate progress based on round count and convergence
+          const progress = calculateMultiCliProgress(syntheses);
+
+          // Build discussion topic for frontend
+          const discussionTopic = buildDiscussionTopic(sessionState, latestSynthesis);
+
+          // Determine status from session state or synthesis convergence
+          const status = sessionState?.status ||
+            (latestSynthesis?.convergence?.recommendation === 'converged' ? 'converged' : 'analyzing');
+
+          // Use plan.json if available, otherwise extract from synthesis
+          const plan = planJson || latestSynthesis;
+          // Use tasks from plan.json if available, otherwise extract from synthesis
+          const tasks = (planJson as any)?.tasks?.length > 0
+            ? normalizePlanJsonTasks((planJson as any).tasks)
+            : extractTasksFromSyntheses(syntheses);
+
+          const session: MultiCliSession = {
+            id: entry.name,
+            type: 'multi-cli-plan',
+            path: sessionPath,
+            createdAt,
+            plan,
+            tasks,
+            progress,
+            // Extended multi-cli specific fields
+            roundCount,
+            topicTitle: sessionState?.task_description || 'Discussion Topic',
+            status,
+            metadata: {
+              roundId: roundCount,
+              timestamp: sessionState?.updated_at || createdAt,
+              currentPhase: sessionState?.current_phase || 1,
+            },
+            discussionTopic,
+            rounds: syntheses,
+            latestSynthesis,
+          };
+
+          return session;
+        }),
+    ))
+      .filter((session): session is MultiCliSession => session !== null)
+      .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+
+    return sessions;
+  } catch (err: any) {
+    if (err?.code === 'ENOENT') return [];
+    console.error(`Error scanning ${dir}:`, err?.message || String(err));
+    return [];
+  }
+}
+
+// NEW Schema types for multi-cli synthesis
+interface SolutionFileAction {
+  file: string;
+  line: number;
+  action: 'modify' | 'create' | 'delete';
+}
+
+interface SolutionTask {
+  id: string;
+  name: string;
+  depends_on: string[];
+  files: SolutionFileAction[];
+  key_point: string | null;
+}
+
+interface SolutionImplementationPlan {
+  approach: string;
+  tasks: SolutionTask[];
+  execution_flow: string;
+  milestones: string[];
+}
+
+interface SolutionDependencies {
+  internal: string[];
+  external: string[];
+}
+
+interface Solution {
+  name: string;
+  source_cli: string[];
+  feasibility: number;  // 0-1
+  effort: 'low' | 'medium' | 'high';
+  risk: 'low' | 'medium' | 'high';
+  summary: string;
+  implementation_plan: SolutionImplementationPlan;
+  dependencies: SolutionDependencies;
+  technical_concerns: string[];
+}
+
+interface SynthesisConvergence {
+  score: number;
+  new_insights: boolean;
+  recommendation: 'converged' | 'continue' | 'user_input_needed';
+}
+
+interface SynthesisCrossVerification {
+  agreements: string[];
+  disagreements: string[];
+  resolution: string;
+}
+
+interface RoundSynthesis {
+  round: number;
+  // NEW schema fields
+  solutions?: Solution[];
+  convergence?: SynthesisConvergence;
+  cross_verification?: SynthesisCrossVerification;
+  clarification_questions?: string[];
+  // OLD schema fields (backward compatibility)
+  converged?: boolean;
+  tasks?: unknown[];
+  synthesis?: unknown;
+  [key: string]: unknown;
+}
+
+/**
+ * Load all synthesis.json files from rounds subdirectories
+ * @param sessionPath - Session directory path
+ * @returns Array of synthesis objects sorted by round number
+ */
+async function loadRoundSyntheses(sessionPath: string): Promise<RoundSynthesis[]> {
+  const roundsDir = join(sessionPath, 'rounds');
+  const syntheses: RoundSynthesis[] = [];
+
+  try {
+    const roundEntries = await readdir(roundsDir, { withFileTypes: true });
+
+    const roundDirs = roundEntries
+      .filter((entry) => entry.isDirectory() && /^\d+$/.test(entry.name))
+      .map((entry) => ({
+        name: entry.name,
+        num: parseInt(entry.name, 10),
+      }))
+      .sort((a, b) => a.num - b.num);
+
+    for (const roundDir of roundDirs) {
+      const synthesisPath = join(roundsDir, roundDir.name, 'synthesis.json');
+      try {
+        const content = await readFile(synthesisPath, 'utf8');
+        const synthesis = JSON.parse(content) as RoundSynthesis;
+        synthesis.round = roundDir.num;
+        syntheses.push(synthesis);
+      } catch (e) {
+        console.warn('Failed to parse synthesis file:', synthesisPath, (e as Error).message);
+      }
+    }
+  } catch (e) {
+    // Ignore ENOENT errors (directory doesn't exist), warn on others
+    if ((e as NodeJS.ErrnoException).code !== 'ENOENT') {
+      console.warn('Failed to read rounds directory:', roundsDir, (e as Error).message);
+    }
+  }
+
+  return syntheses;
+}
+
+// Extended Progress interface for multi-cli sessions
+interface MultiCliProgress extends Progress {
+  convergenceScore?: number;
+  recommendation?: 'converged' | 'continue' | 'user_input_needed';
+  solutionsCount?: number;
+  avgFeasibility?: number;
+}
+
+/**
+ * Calculate progress for multi-cli-plan sessions
+ * Uses new convergence.score and convergence.recommendation when available
+ * Falls back to old converged boolean for backward compatibility
+ * @param syntheses - Array of round syntheses
+ * @returns Progress info with convergence metrics
+ */
+function calculateMultiCliProgress(syntheses: RoundSynthesis[]): MultiCliProgress {
+  if (syntheses.length === 0) {
+    return { total: 0, completed: 0, percentage: 0 };
+  }
+
+  const latestSynthesis = syntheses[syntheses.length - 1];
+
+  // NEW schema: Use convergence object
+  if (latestSynthesis.convergence) {
+    const { score, recommendation } = latestSynthesis.convergence;
+    const isConverged = recommendation === 'converged';
+
+    // Calculate solutions metrics
+    const solutions = latestSynthesis.solutions || [];
+    const solutionsCount = solutions.length;
+    const avgFeasibility = solutionsCount > 0
+      ? solutions.reduce((sum, s) => sum + (s.feasibility || 0), 0) / solutionsCount
+      : 0;
+
+    // Total is based on rounds, percentage derived from convergence score
+    const total = syntheses.length;
+    const completed = isConverged ? total : Math.max(0, total - 1);
+    const percentage = isConverged ? 100 : Math.round(score * 100);
+
+    return {
+      total,
+      completed,
+      percentage,
+      convergenceScore: score,
+      recommendation,
+      solutionsCount,
+      avgFeasibility: Math.round(avgFeasibility * 100) / 100
+    };
+  }
+
+  // OLD schema: Fallback to converged boolean
+  const isConverged = latestSynthesis.converged === true;
+  const total = syntheses.length;
+  const completed = isConverged ? total : Math.max(0, total - 1);
+  const percentage = isConverged ? 100 : Math.round((completed / Math.max(total, 1)) * 100);
+
+  return { total, completed, percentage };
+}
+
+/**
+ * Extract tasks from synthesis objects
+ * NEW schema: Extract from solutions[].implementation_plan.tasks
+ * OLD schema: Extract from tasks[] array directly
+ * @param syntheses - Array of round syntheses
+ * @returns Normalized tasks from latest synthesis
+ */
+function extractTasksFromSyntheses(syntheses: RoundSynthesis[]): NormalizedTask[] {
+  if (syntheses.length === 0) return [];
+
+  const latestSynthesis = syntheses[syntheses.length - 1];
+
+  // NEW schema: Extract tasks from solutions
+  if (latestSynthesis.solutions && Array.isArray(latestSynthesis.solutions)) {
+    const allTasks: NormalizedTask[] = [];
+
+    for (const solution of latestSynthesis.solutions) {
+      const implPlan = solution.implementation_plan;
+      if (!implPlan?.tasks || !Array.isArray(implPlan.tasks)) continue;
+
+      for (const task of implPlan.tasks) {
+        const normalizedTask = normalizeSolutionTask(task, solution);
+        if (normalizedTask) {
+          allTasks.push(normalizedTask);
+        }
+      }
+    }
+
+    // Sort by task ID
+    return allTasks.sort((a, b) => {
+      const aNum = parseInt(a.id?.replace(/\D/g, '') || '0');
+      const bNum = parseInt(b.id?.replace(/\D/g, '') || '0');
+      return aNum - bNum;
+    });
+  }
+
+  // OLD schema: Extract from tasks array directly
+  const tasks = latestSynthesis.tasks;
+  if (!Array.isArray(tasks)) return [];
+
+  return tasks
+    .map((task) => normalizeTask(task))
+    .filter((task): task is NormalizedTask => task !== null);
+}
+
+/**
+ * Normalize a solution task from NEW schema to NormalizedTask
+ * @param task - SolutionTask from new schema
+ * @param solution - Parent solution for context
+ * @returns Normalized task
+ */
+function normalizeSolutionTask(task: SolutionTask, solution: Solution): NormalizedTask | null {
+  if (!task || !task.id) return null;
+
+  return {
+    id: task.id,
+    title: task.name || 'Untitled Task',
+    status: (task as unknown as { status?: string }).status || 'pending',
+    meta: {
+      type: 'implementation',
+      agent: null,
+      scope: solution.name || null,
+      module: null
+    },
+    context: {
+      requirements: task.key_point ? [task.key_point] : [],
+      focus_paths: task.files?.map(f => f.file) || [],
+      acceptance: [],
+      depends_on: task.depends_on || []
+    },
+    flow_control: {
+      implementation_approach: task.files?.map((f, i) => ({
+        step: `Step ${i + 1}`,
+        action: `${f.action} ${f.file}${f.line ? ` at line ${f.line}` : ''}`
+      })) || []
+    },
+    _raw: {
+      task,
+      solution: {
+        name: solution.name,
+        source_cli: solution.source_cli,
+        feasibility: solution.feasibility,
+        effort: solution.effort,
+        risk: solution.risk
+      }
+    }
+  };
+}
+
+/**
+ * Normalize tasks from plan.json format to NormalizedTask[]
+ * plan.json tasks have: id, name, description, depends_on, status, files, key_point, acceptance_criteria
+ * @param tasks - Tasks array from plan.json
+ * @returns Normalized tasks
+ */
+function normalizePlanJsonTasks(tasks: unknown[]): NormalizedTask[] {
+  if (!Array.isArray(tasks)) return [];
+
+  return tasks.map((task: any): NormalizedTask | null => {
+    if (!task || !task.id) return null;
+
+    return {
+      id: task.id,
+      title: task.name || task.title || 'Untitled Task',
+      status: task.status || 'pending',
+      meta: {
+        type: 'implementation',
+        agent: null,
+        scope: task.scope || null,
+        module: null
+      },
+      context: {
+        requirements: task.description ? [task.description] : (task.key_point ? [task.key_point] : []),
+        focus_paths: task.files?.map((f: any) => typeof f === 'string' ? f : f.file) || [],
+        acceptance: task.acceptance_criteria || [],
+        depends_on: task.depends_on || []
+      },
+      flow_control: {
+        implementation_approach: task.files?.map((f: any, i: number) => {
+          const filePath = typeof f === 'string' ? f : f.file;
+          const action = typeof f === 'string' ? 'modify' : f.action;
+          const line = typeof f === 'string' ? null : f.line;
+          return {
+            step: `Step ${i + 1}`,
+            action: `${action} ${filePath}${line ? ` at line ${line}` : ''}`
+          };
+        }) || []
+      },
+      _raw: {
+        task,
+        estimated_complexity: task.estimated_complexity
+      }
+    };
+  }).filter((task): task is NormalizedTask => task !== null);
+}
+
 /**
  * Load plan.json or fix-plan.json from session directory
  * @param sessionPath - Session directory path
@@ -368,14 +829,19 @@ function calculateProgress(tasks: NormalizedTask[]): Progress {
 /**
  * Get detailed lite task info
  * @param workflowDir - Workflow directory
- * @param type - 'lite-plan' or 'lite-fix'
+ * @param type - 'lite-plan', 'lite-fix', or 'multi-cli-plan'
  * @param sessionId - Session ID
  * @returns Detailed task info
  */
 export async function getLiteTaskDetail(workflowDir: string, type: string, sessionId: string): Promise<LiteTaskDetail | null> {
-  const dir = type === 'lite-plan'
-    ? join(workflowDir, '.lite-plan', sessionId)
-    : join(workflowDir, '.lite-fix', sessionId);
+  let dir: string;
+  if (type === 'lite-plan') {
+    dir = join(workflowDir, '.lite-plan', sessionId);
+  } else if (type === 'multi-cli-plan') {
+    dir = join(workflowDir, '.multi-cli-plan', sessionId);
+  } else {
+    dir = join(workflowDir, '.lite-fix', sessionId);
+  }
 
   try {
     const stats = await stat(dir);
@@ -384,6 +850,29 @@ export async function getLiteTaskDetail(workflowDir: string, type: string, sessi
     return null;
   }
 
+  // For multi-cli-plan, use synthesis-based loading
+  if (type === 'multi-cli-plan') {
+    const [syntheses, explorations, clarifications] = await Promise.all([
+      loadRoundSyntheses(dir),
+      loadExplorations(dir),
+      loadClarifications(dir),
+    ]);
+
+    const latestSynthesis = syntheses.length > 0 ? syntheses[syntheses.length - 1] : null;
+
+    const detail: LiteTaskDetail = {
+      id: sessionId,
+      type,
+      path: dir,
+      plan: latestSynthesis,
+      tasks: extractTasksFromSyntheses(syntheses),
+      explorations,
+      clarifications,
+    };
+
+    return detail;
+  }
+
   const [plan, tasks, explorations, clarifications, diagnoses] = await Promise.all([
     loadPlanJson(dir),
     loadTaskJsons(dir),