claude-code-workflow 6.3.34 → 6.3.37

package/ccw/src/commands/loop.ts

@@ -0,0 +1,344 @@
+/**
+ * Loop Command
+ * CCW Loop System - CLI interface for loop management
+ * Reference: .workflow/.scratchpad/loop-system-complete-design-20260121.md section 4.3
+ */
+
+import chalk from 'chalk';
+import { readFile } from 'fs/promises';
+import { join, resolve } from 'path';
+import { existsSync } from 'fs';
+import { LoopManager } from '../tools/loop-manager.js';
+import type { TaskLoopControl } from '../types/loop.js';
+
+// Minimal Task interface for task config files
+interface Task {
+  id: string;
+  title?: string;
+  loop_control?: TaskLoopControl;
+}
+
+/**
+ * Read task configuration
+ */
+async function readTaskConfig(taskId: string, workflowDir: string): Promise<Task> {
+  const taskFile = join(workflowDir, '.task', `${taskId}.json`);
+
+  if (!existsSync(taskFile)) {
+    throw new Error(`Task file not found: ${taskFile}`);
+  }
+
+  const content = await readFile(taskFile, 'utf-8');
+  return JSON.parse(content) as Task;
+}
+
+/**
+ * Find active workflow session
+ */
+function findActiveSession(cwd: string): string | null {
+  const workflowDir = join(cwd, '.workflow', 'active');
+
+  if (!existsSync(workflowDir)) {
+    return null;
+  }
+
+  const { readdirSync } = require('fs');
+  const sessions = readdirSync(workflowDir).filter((d: string) => d.startsWith('WFS-'));
+
+  if (sessions.length === 0) {
+    return null;
+  }
+
+  if (sessions.length === 1) {
+    return join(cwd, '.workflow', 'active', sessions[0]);
+  }
+
+  // Multiple sessions, require user to specify
+  console.error(chalk.red('\n  Error: Multiple active sessions found:'));
+  sessions.forEach((s: string) => console.error(chalk.gray(`    - ${s}`)));
+  console.error(chalk.yellow('\n  Please specify session with --session <name>\n'));
+  return null;
+}
+
+/**
+ * Get status badge with color
+ */
+function getStatusBadge(status: string): string {
+  switch (status) {
+    case 'created':
+      return chalk.gray('○ created');
+    case 'running':
+      return chalk.cyan('● running');
+    case 'paused':
+      return chalk.yellow('⏸ paused');
+    case 'completed':
+      return chalk.green('✓ completed');
+    case 'failed':
+      return chalk.red('✗ failed');
+    default:
+      return status;
+  }
+}
+
+/**
+ * Format time ago
+ */
+function timeAgo(timestamp: string): string {
+  const now = Date.now();
+  const then = new Date(timestamp).getTime();
+  const diff = Math.floor((now - then) / 1000);
+
+  if (diff < 60) return `${diff}s ago`;
+  if (diff < 3600) return `${Math.floor(diff / 60)}m ago`;
+  if (diff < 86400) return `${Math.floor(diff / 3600)}h ago`;
+  return `${Math.floor(diff / 86400)}d ago`;
+}
+
+/**
+ * Start action
+ */
+async function startAction(taskId: string, options: { session?: string }): Promise<void> {
+  const currentCwd = process.cwd();
+
+  // Find workflow session
+  let sessionDir: string | null;
+
+  if (options.session) {
+    sessionDir = join(currentCwd, '.workflow', 'active', options.session);
+    if (!existsSync(sessionDir)) {
+      console.error(chalk.red(`\n  Error: Session not found: ${options.session}\n`));
+      process.exit(1);
+    }
+  } else {
+    sessionDir = findActiveSession(currentCwd);
+    if (!sessionDir) {
+      console.error(chalk.red('\n  Error: No active workflow session found.'));
+      console.error(chalk.gray('  Run "ccw workflow:plan" first to create a session.\n'));
+      process.exit(1);
+    }
+  }
+
+  console.log(chalk.cyan(`  Using session: ${sessionDir.split(/[\\/]/).pop()}`));
+
+  // Read task config
+  const task = await readTaskConfig(taskId, sessionDir);
+
+  if (!task.loop_control?.enabled) {
+    console.error(chalk.red(`\n  Error: Task ${taskId} does not have loop enabled.\n`));
+    process.exit(1);
+  }
+
+  // Start loop
+  const loopManager = new LoopManager(sessionDir);
+  const loopId = await loopManager.startLoop(task as any); // Task interface compatible
+
+  console.log(chalk.green(`\n  ✓ Loop started: ${loopId}`));
+  console.log(chalk.dim(`  Status:  ccw loop status ${loopId}`));
+  console.log(chalk.dim(`  Pause:   ccw loop pause ${loopId}`));
+  console.log(chalk.dim(`  Stop:    ccw loop stop ${loopId}\n`));
+}
+
+/**
+ * Status action
+ */
+async function statusAction(loopId: string | undefined, options: { session?: string }): Promise<void> {
+  const currentCwd = process.cwd();
+  const sessionDir = options?.session
+    ? join(currentCwd, '.workflow', 'active', options.session)
+    : findActiveSession(currentCwd);
+
+  if (!sessionDir) {
+    console.error(chalk.red('\n  Error: No active session found.\n'));
+    process.exit(1);
+  }
+
+  const loopManager = new LoopManager(sessionDir);
+
+  if (loopId) {
+    // Show single loop detail
+    const state = await loopManager.getStatus(loopId);
+
+    console.log(chalk.bold.cyan('\n  Loop Status\n'));
+    console.log(`  ${chalk.gray('ID:')}         ${state.loop_id}`);
+    console.log(`  ${chalk.gray('Task:')}       ${state.task_id}`);
+    console.log(`  ${chalk.gray('Status:')}     ${getStatusBadge(state.status)}`);
+    console.log(`  ${chalk.gray('Iteration:')}  ${state.current_iteration}/${state.max_iterations}`);
+    console.log(`  ${chalk.gray('Step:')}       ${state.current_cli_step + 1}/${state.cli_sequence.length}`);
+    console.log(`  ${chalk.gray('Created:')}    ${state.created_at}`);
+    console.log(`  ${chalk.gray('Updated:')}    ${state.updated_at}`);
+
+    if (state.failure_reason) {
+      console.log(`  ${chalk.gray('Reason:')}     ${chalk.red(state.failure_reason)}`);
+    }
+
+    console.log(chalk.bold.cyan('\n  CLI Sequence\n'));
+    state.cli_sequence.forEach((step, i) => {
+      const current = i === state.current_cli_step ? chalk.cyan('→') : ' ';
+      console.log(`  ${current} ${i + 1}. ${chalk.bold(step.step_id)} (${step.tool})`);
+    });
+
+    if (state.execution_history && state.execution_history.length > 0) {
+      console.log(chalk.bold.cyan('\n  Recent Executions\n'));
+      const recent = state.execution_history.slice(-5);
+      recent.forEach(exec => {
+        const status = exec.exit_code === 0 ? chalk.green('✓') : chalk.red('✗');
+        console.log(`  ${status} ${exec.step_id} (${exec.tool}) - ${(exec.duration_ms / 1000).toFixed(1)}s`);
+      });
+    }
+
+    console.log();
+  } else {
+    // List all loops
+    const loops = await loopManager.listLoops();
+
+    if (loops.length === 0) {
+      console.log(chalk.yellow('\n  No loops found.\n'));
+      return;
+    }
+
+    console.log(chalk.bold.cyan('\n  Active Loops\n'));
+    console.log(chalk.gray('  Status  ID                                Iteration  Task'));
+    console.log(chalk.gray('  ' + '─'.repeat(70)));
+
+    loops.forEach(loop => {
+      const status = getStatusBadge(loop.status);
+      const iteration = `${loop.current_iteration}/${loop.max_iterations}`;
+      console.log(`  ${status}  ${chalk.dim(loop.loop_id.padEnd(35))}  ${iteration.padEnd(9)}  ${loop.task_id}`);
+    });
+
+    console.log();
+  }
+}
+
+/**
+ * Pause action
+ */
+async function pauseAction(loopId: string, options: { session?: string }): Promise<void> {
+  const currentCwd = process.cwd();
+  const sessionDir = options.session
+    ? join(currentCwd, '.workflow', 'active', options.session)
+    : findActiveSession(currentCwd);
+
+  if (!sessionDir) {
+    console.error(chalk.red('\n  Error: No active session found.\n'));
+    process.exit(1);
+  }
+
+  const loopManager = new LoopManager(sessionDir);
+  await loopManager.pauseLoop(loopId);
+}
+
+/**
+ * Resume action
+ */
+async function resumeAction(loopId: string, options: { session?: string }): Promise<void> {
+  const currentCwd = process.cwd();
+  const sessionDir = options.session
+    ? join(currentCwd, '.workflow', 'active', options.session)
+    : findActiveSession(currentCwd);
+
+  if (!sessionDir) {
+    console.error(chalk.red('\n  Error: No active session found.\n'));
+    process.exit(1);
+  }
+
+  const loopManager = new LoopManager(sessionDir);
+  await loopManager.resumeLoop(loopId);
+}
+
+/**
+ * Stop action
+ */
+async function stopAction(loopId: string, options: { session?: string }): Promise<void> {
+  const currentCwd = process.cwd();
+  const sessionDir = options.session
+    ? join(currentCwd, '.workflow', 'active', options.session)
+    : findActiveSession(currentCwd);
+
+  if (!sessionDir) {
+    console.error(chalk.red('\n  Error: No active session found.\n'));
+    process.exit(1);
+  }
+
+  const loopManager = new LoopManager(sessionDir);
+  await loopManager.stopLoop(loopId);
+}
+
+/**
+ * Loop command entry point
+ */
+export async function loopCommand(
+  subcommand: string,
+  args: string | string[],
+  options: any
+): Promise<void> {
+  const argsArray = Array.isArray(args) ? args : (args ? [args] : []);
+
+  try {
+    switch (subcommand) {
+      case 'start':
+        if (!argsArray[0]) {
+          console.error(chalk.red('\n  Error: Task ID is required\n'));
+          console.error(chalk.gray('  Usage: ccw loop start <task-id> [--session <name>]\n'));
+          process.exit(1);
+        }
+        await startAction(argsArray[0], options);
+        break;
+
+      case 'status':
+        await statusAction(argsArray[0], options);
+        break;
+
+      case 'pause':
+        if (!argsArray[0]) {
+          console.error(chalk.red('\n  Error: Loop ID is required\n'));
+          console.error(chalk.gray('  Usage: ccw loop pause <loop-id>\n'));
+          process.exit(1);
+        }
+        await pauseAction(argsArray[0], options);
+        break;
+
+      case 'resume':
+        if (!argsArray[0]) {
+          console.error(chalk.red('\n  Error: Loop ID is required\n'));
+          console.error(chalk.gray('  Usage: ccw loop resume <loop-id>\n'));
+          process.exit(1);
+        }
+        await resumeAction(argsArray[0], options);
+        break;
+
+      case 'stop':
+        if (!argsArray[0]) {
+          console.error(chalk.red('\n  Error: Loop ID is required\n'));
+          console.error(chalk.gray('  Usage: ccw loop stop <loop-id>\n'));
+          process.exit(1);
+        }
+        await stopAction(argsArray[0], options);
+        break;
+
+      default:
+        // Show help
+        console.log(chalk.bold.cyan('\n  CCW Loop System\n'));
+        console.log('  Manage automated CLI execution loops\n');
+        console.log('  Subcommands:');
+        console.log(chalk.gray('    start <task-id>    Start a new loop from task configuration'));
+        console.log(chalk.gray('    status [loop-id]   Show loop status (all or specific)'));
+        console.log(chalk.gray('    pause <loop-id>    Pause a running loop'));
+        console.log(chalk.gray('    resume <loop-id>   Resume a paused loop'));
+        console.log(chalk.gray('    stop <loop-id>     Stop a loop'));
+        console.log();
+        console.log('  Options:');
+        console.log(chalk.gray('    --session <name>   Specify workflow session'));
+        console.log();
+        console.log('  Examples:');
+        console.log(chalk.gray('    ccw loop start IMPL-3'));
+        console.log(chalk.gray('    ccw loop status'));
+        console.log(chalk.gray('    ccw loop status loop-IMPL-3-20260121120000'));
+        console.log(chalk.gray('    ccw loop pause loop-IMPL-3-20260121120000'));
+        console.log();
+    }
+  } catch (error) {
+    console.error(chalk.red(`\n  ✗ Error: ${error instanceof Error ? error.message : error}\n`));
+    process.exit(1);
+  }
+}

package/ccw/src/core/dashboard-generator.ts

@@ -99,7 +99,10 @@ const MODULE_CSS_FILES = [
   '29-help.css',
   '30-core-memory.css',
   '31-api-settings.css',
-  '34-discovery.css'
+  '32-issue-manager.css',
+  '33-cli-stream-viewer.css',
+  '34-discovery.css',
+  '36-loop-monitor.css'
 ];
 
 const MODULE_FILES = [

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

@@ -6,6 +6,7 @@ import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, unlinkS
 import { dirname, join, relative } from 'path';
 import { homedir } from 'os';
 import type { RouteContext } from './types.js';
+import { getDefaultTool } from '../../tools/claude-cli-tools.js';
 
 interface ClaudeFile {
   id: string;
@@ -549,7 +550,8 @@ export async function handleClaudeRoutes(ctx: RouteContext): Promise<boolean> {
   // API: CLI Sync (analyze and update CLAUDE.md using CLI tools)
   if (pathname === '/api/memory/claude/sync' && req.method === 'POST') {
     handlePostRequest(req, res, async (body: any) => {
-      const { level, path: modulePath, tool = 'gemini', mode = 'update', targets } = body;
+      const { level, path: modulePath, tool, mode = 'update', targets } = body;
+      const resolvedTool = tool || getDefaultTool(initialPath);
 
       if (!level) {
         return { error: 'Missing level parameter', status: 400 };
@@ -598,7 +600,7 @@ export async function handleClaudeRoutes(ctx: RouteContext): Promise<boolean> {
           type: 'CLI_EXECUTION_STARTED',
           payload: {
             executionId: syncId,
-            tool: tool === 'qwen' ? 'qwen' : 'gemini',
+            tool: resolvedTool,
             mode: 'analysis',
             category: 'internal',
             context: 'claude-sync',
@@ -629,7 +631,7 @@ export async function handleClaudeRoutes(ctx: RouteContext): Promise<boolean> {
 
         const startTime = Date.now();
         const result = await executeCliTool({
-          tool: tool === 'qwen' ? 'qwen' : 'gemini',
+          tool: resolvedTool,
           prompt: cliPrompt,
           mode: 'analysis',
           format: 'plain',

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

@@ -60,9 +60,35 @@ interface ActiveExecution {
   startTime: number;
   output: string;
   status: 'running' | 'completed' | 'error';
+  completedTimestamp?: number;  // When execution completed (for 5-minute retention)
 }
 
 const activeExecutions = new Map<string, ActiveExecution>();
+const EXECUTION_RETENTION_MS = 5 * 60 * 1000;  // 5 minutes
+
+/**
+ * Cleanup stale completed executions older than retention period
+ * Runs periodically to prevent memory buildup
+ */
+export function cleanupStaleExecutions(): void {
+  const now = Date.now();
+  const staleIds: string[] = [];
+
+  for (const [id, exec] of activeExecutions.entries()) {
+    if (exec.completedTimestamp && (now - exec.completedTimestamp) > EXECUTION_RETENTION_MS) {
+      staleIds.push(id);
+    }
+  }
+
+  staleIds.forEach(id => {
+    activeExecutions.delete(id);
+    console.log(`[ActiveExec] Cleaned up stale execution: ${id}`);
+  });
+
+  if (staleIds.length > 0) {
+    console.log(`[ActiveExec] Cleaned up ${staleIds.length} stale execution(s), remaining: ${activeExecutions.size}`);
+  }
+}
 
 /**
  * Get all active CLI executions
@@ -113,19 +139,12 @@ export function updateActiveExecution(event: {
       activeExec.output += output;
     }
   } else if (type === 'completed') {
-    // Mark as completed instead of immediately deleting
-    // Keep execution visible for 5 minutes to allow page refreshes to see it
+    // Mark as completed with timestamp for retention-based cleanup
     const activeExec = activeExecutions.get(executionId);
     if (activeExec) {
       activeExec.status = success ? 'completed' : 'error';
-
-      // Auto-cleanup after 5 minutes
-      setTimeout(() => {
-        activeExecutions.delete(executionId);
-        console.log(`[ActiveExec] Auto-cleaned completed execution: ${executionId}`);
-      }, 5 * 60 * 1000);
-
-      console.log(`[ActiveExec] Marked as ${activeExec.status}, will auto-clean in 5 minutes`);
+      activeExec.completedTimestamp = Date.now();
+      console.log(`[ActiveExec] Marked as ${activeExec.status}, retained for ${EXECUTION_RETENTION_MS / 1000}s`);
     }
   }
 }
@@ -139,7 +158,10 @@ export async function handleCliRoutes(ctx: RouteContext): Promise<boolean> {
 
   // API: Get Active CLI Executions (for state recovery)
   if (pathname === '/api/cli/active' && req.method === 'GET') {
-    const executions = getActiveExecutions();
+    const executions = getActiveExecutions().map(exec => ({
+      ...exec,
+      isComplete: exec.status !== 'running'
+    }));
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify({ executions }));
     return true;
@@ -664,8 +686,13 @@ export async function handleCliRoutes(ctx: RouteContext): Promise<boolean> {
           });
         });
 
-        // Remove from active executions on completion
-        activeExecutions.delete(executionId);
+        // Mark as completed with timestamp for retention-based cleanup (not immediate delete)
+        const activeExec = activeExecutions.get(executionId);
+        if (activeExec) {
+          activeExec.status = result.success ? 'completed' : 'error';
+          activeExec.completedTimestamp = Date.now();
+          console.log(`[ActiveExec] Direct execution ${executionId} marked as ${activeExec.status}, retained for ${EXECUTION_RETENTION_MS / 1000}s`);
+        }
 
         // Broadcast completion
         broadcastToClients({
@@ -684,8 +711,13 @@ export async function handleCliRoutes(ctx: RouteContext): Promise<boolean> {
         };
 
       } catch (error: unknown) {
-        // Remove from active executions on error
-        activeExecutions.delete(executionId);
+        // Mark as completed with timestamp for retention-based cleanup (not immediate delete)
+        const activeExec = activeExecutions.get(executionId);
+        if (activeExec) {
+          activeExec.status = 'error';
+          activeExec.completedTimestamp = Date.now();
+          console.log(`[ActiveExec] Direct execution ${executionId} marked as error, retained for ${EXECUTION_RETENTION_MS / 1000}s`);
+        }
 
         broadcastToClients({
           type: 'CLI_EXECUTION_ERROR',

package/ccw/src/core/routes/cli-settings-routes.ts

@@ -16,6 +16,7 @@ import {
 } from '../../config/cli-settings-manager.js';
 import type { SaveEndpointRequest } from '../../types/cli-settings.js';
 import { validateSettings } from '../../types/cli-settings.js';
+import { syncBuiltinToolsAvailability, getBuiltinToolsSyncReport } from '../../tools/claude-cli-tools.js';
 
 /**
  * Handle CLI Settings routes
@@ -228,5 +229,51 @@ export async function handleCliSettingsRoutes(ctx: RouteContext): Promise<boolea
     return true;
   }
 
+  // ========== SYNC BUILTIN TOOLS AVAILABILITY ==========
+  // POST /api/cli/settings/sync-tools
+  if (pathname === '/api/cli/settings/sync-tools' && req.method === 'POST') {
+    handlePostRequest(req, res, async (body: any) => {
+      const { initialPath } = ctx;
+      try {
+        const result = await syncBuiltinToolsAvailability(initialPath);
+
+        // Broadcast update event
+        broadcastToClients({
+          type: 'CLI_TOOLS_CONFIG_UPDATED',
+          payload: {
+            tools: result.config,
+            timestamp: new Date().toISOString()
+          }
+        });
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          success: true,
+          changes: result.changes,
+          config: result.config
+        }));
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: (err as Error).message }));
+      }
+    });
+    return true;
+  }
+
+  // GET /api/cli/settings/sync-report
+  if (pathname === '/api/cli/settings/sync-report' && req.method === 'GET') {
+    try {
+      const { initialPath } = ctx;
+      const report = await getBuiltinToolsSyncReport(initialPath);
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(report));
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: (err as Error).message }));
+    }
+    return true;
+  }
+
   return false;
 }

package/ccw/src/core/routes/codexlens/semantic-handlers.ts

@@ -16,6 +16,7 @@ import {
 } from '../../../utils/uv-manager.js';
 import type { RouteContext } from '../types.js';
 import { extractJSON } from './utils.js';
+import { getDefaultTool } from '../../../tools/claude-cli-tools.js';
 
 export async function handleCodexLensSemanticRoutes(ctx: RouteContext): Promise<boolean> {
   const { pathname, url, req, res, initialPath, handlePostRequest } = ctx;
@@ -66,14 +67,14 @@ export async function handleCodexLensSemanticRoutes(ctx: RouteContext): Promise<
   // API: CodexLens LLM Enhancement (run enhance command)
   if (pathname === '/api/codexlens/enhance' && req.method === 'POST') {
     handlePostRequest(req, res, async (body) => {
-      const { path: projectPath, tool = 'gemini', batchSize = 5, timeoutMs = 300000 } = body as {
+      const { path: projectPath, tool, batchSize = 5, timeoutMs = 300000 } = body as {
         path?: unknown;
         tool?: unknown;
         batchSize?: unknown;
         timeoutMs?: unknown;
       };
       const targetPath = typeof projectPath === 'string' && projectPath.trim().length > 0 ? projectPath : initialPath;
-      const resolvedTool = typeof tool === 'string' && tool.trim().length > 0 ? tool : 'gemini';
+      const resolvedTool = typeof tool === 'string' && tool.trim().length > 0 ? tool : getDefaultTool(targetPath);
       const resolvedBatchSize = typeof batchSize === 'number' ? batchSize : Number(batchSize);
       const resolvedTimeoutMs = typeof timeoutMs === 'number' ? timeoutMs : Number(timeoutMs);
 

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

@@ -6,6 +6,7 @@ import { getEmbeddingStatus, generateEmbeddings } from '../memory-embedder-bridg
 import { checkSemanticStatus } from '../../tools/codex-lens.js';
 import { StoragePaths } from '../../config/storage-paths.js';
 import { join } from 'path';
+import { getDefaultTool } from '../../tools/claude-cli-tools.js';
 
 /**
  * Route context interface
@@ -173,12 +174,13 @@ export async function handleCoreMemoryRoutes(ctx: RouteContext): Promise<boolean
     const memoryId = pathname.replace('/api/core-memory/memories/', '').replace('/summary', '');
 
     handlePostRequest(req, res, async (body) => {
-      const { tool = 'gemini', path: projectPath } = body;
+      const { tool, path: projectPath } = body;
       const basePath = projectPath || initialPath;
+      const resolvedTool = tool || getDefaultTool(basePath);
 
       try {
         const store = getCoreMemoryStore(basePath);
-        const summary = await store.generateSummary(memoryId, tool);
+        const summary = await store.generateSummary(memoryId, resolvedTool);
 
         // Broadcast update event
         broadcastToClients({

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

@@ -6,6 +6,7 @@ import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
 import { join } from 'path';
 import { validatePath as validateAllowedPath } from '../../utils/path-validator.js';
 import type { RouteContext } from './types.js';
+import { getDefaultTool } from '../../tools/claude-cli-tools.js';
 
 // ========================================
 // Constants
@@ -471,7 +472,7 @@ export async function handleFilesRoutes(ctx: RouteContext): Promise<boolean> {
 
       const {
         path: targetPath,
-        tool = 'gemini',
+        tool,
         strategy = 'single-layer'
       } = body as { path?: unknown; tool?: unknown; strategy?: unknown };
 
@@ -481,9 +482,10 @@ export async function handleFilesRoutes(ctx: RouteContext): Promise<boolean> {
 
       try {
         const validatedPath = await validateAllowedPath(targetPath, { mustExist: true, allowedDirectories: [initialPath] });
+        const resolvedTool = typeof tool === 'string' && tool.trim().length > 0 ? tool : getDefaultTool(validatedPath);
         return await triggerUpdateClaudeMd(
           validatedPath,
-          typeof tool === 'string' ? tool : 'gemini',
+          resolvedTool,
           typeof strategy === 'string' ? strategy : 'single-layer'
         );
       } catch (err) {

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

@@ -39,6 +39,9 @@ function readSettingsFile(filePath: string): Record<string, unknown> {
       return {};
     }
     const content = readFileSync(filePath, 'utf8');
+    if (!content.trim()) {
+      return {};
+    }
     return JSON.parse(content);
   } catch (error: unknown) {
     console.error(`Error reading settings file ${filePath}:`, error);