6.3.31

- 移除 --timeout 命令行选项和内部超时处理逻辑
- 进程生命周期跟随父进程（bash）状态
- 简化代码，超时控制交由外部调用者管理

ccw/src/cli.ts

@@ -177,7 +177,7 @@ export function run(argv: string[]): void {
     .option('--model <model>', 'Model override')
     .option('--cd <path>', 'Working directory')
     .option('--includeDirs <dirs>', 'Additional directories (--include-directories for gemini/qwen, --add-dir for codex/claude)')
-    .option('--timeout <ms>', 'Timeout in milliseconds (0=disabled, controlled by external caller)', '0')
+    // --timeout removed - controlled by external caller (bash timeout)
     .option('--stream', 'Enable streaming output (default: non-streaming with caching)')
     .option('--limit <n>', 'History limit')
     .option('--status <status>', 'Filter by status')

ccw/src/commands/cli.ts

@@ -116,7 +116,7 @@ interface CliExecOptions {
   model?: string;
   cd?: string;
   includeDirs?: string;
-  timeout?: string;
+  // timeout removed - controlled by external caller (bash timeout)
   stream?: boolean; // Enable streaming (default: false, caches output)
   resume?: string | boolean; // true = last, string = execution ID, comma-separated for merge
   id?: string; // Custom execution ID (e.g., IMPL-001-step1)
@@ -535,7 +535,7 @@ async function statusAction(debug?: boolean): Promise<void> {
  * @param {Object} options - CLI options
  */
 async function execAction(positionalPrompt: string | undefined, options: CliExecOptions): Promise<void> {
-  const { prompt: optionPrompt, file, tool = 'gemini', mode = 'analysis', model, cd, includeDirs, timeout, stream, resume, id, noNative, cache, injectMode, debug } = options;
+  const { prompt: optionPrompt, file, tool = 'gemini', mode = 'analysis', model, cd, includeDirs, stream, resume, id, noNative, cache, injectMode, debug } = options;
 
   // Enable debug mode if --debug flag is set
   if (debug) {
@@ -842,7 +842,7 @@ async function execAction(positionalPrompt: string | undefined, options: CliExec
       model,
       cd,
       includeDirs,
-      timeout: timeout ? parseInt(timeout, 10) : 0, // 0 = no internal timeout, controlled by external caller
+      // timeout removed - controlled by external caller (bash timeout)
       resume,
       id, // custom execution ID
       noNative,
@@ -1221,7 +1221,7 @@ export async function cliCommand(
         console.log(chalk.gray('    --model <model>     Model override'));
         console.log(chalk.gray('    --cd <path>         Working directory'));
         console.log(chalk.gray('    --includeDirs <dirs>  Additional directories'));
-        console.log(chalk.gray('    --timeout <ms>      Timeout (default: 0=disabled)'));
+        // --timeout removed - controlled by external caller (bash timeout)
         console.log(chalk.gray('    --resume [id]       Resume previous session'));
         console.log(chalk.gray('    --cache <items>     Cache: comma-separated @patterns and text'));
         console.log(chalk.gray('    --inject-mode <m>   Inject mode: none, full, progressive'));

ccw/src/core/data-aggregator.ts

@@ -589,6 +589,18 @@ function loadProjectOverview(workflowDir: string): ProjectOverview | null {
     const statistics = (projectData.statistics || developmentStatus?.statistics) as Record<string, unknown> | undefined;
     const metadata = projectData._metadata as Record<string, unknown> | undefined;
 
+    // Helper to extract string array from mixed array (handles both string[] and {name: string}[])
+    const extractStringArray = (arr: unknown[] | undefined): string[] => {
+      if (!arr) return [];
+      return arr.map(item => {
+        if (typeof item === 'string') return item;
+        if (typeof item === 'object' && item !== null && 'name' in item) {
+          return String((item as { name: unknown }).name);
+        }
+        return String(item);
+      });
+    };
+
     // Load guidelines from separate file if exists
     let guidelines: ProjectGuidelines | null = null;
     if (existsSync(guidelinesFile)) {
@@ -633,17 +645,17 @@ function loadProjectOverview(workflowDir: string): ProjectOverview | null {
       description: (overview?.description as string) || '',
       initializedAt: (projectData.initialized_at as string) || null,
       technologyStack: {
-        languages: (technologyStack?.languages as string[]) || [],
-        frameworks: (technologyStack?.frameworks as string[]) || [],
-        build_tools: (technologyStack?.build_tools as string[]) || [],
-        test_frameworks: (technologyStack?.test_frameworks as string[]) || []
+        languages: extractStringArray(technologyStack?.languages),
+        frameworks: extractStringArray(technologyStack?.frameworks),
+        build_tools: extractStringArray(technologyStack?.build_tools),
+        test_frameworks: extractStringArray(technologyStack?.test_frameworks)
       },
       architecture: {
         style: (architecture?.style as string) || 'Unknown',
-        layers: (architecture?.layers as string[]) || [],
-        patterns: (architecture?.patterns as string[]) || []
+        layers: extractStringArray(architecture?.layers as unknown[] | undefined),
+        patterns: extractStringArray(architecture?.patterns as unknown[] | undefined)
       },
-      keyComponents: (overview?.key_components as string[]) || [],
+      keyComponents: extractStringArray(overview?.key_components as unknown[] | undefined),
       features: (projectData.features as unknown[]) || [],
       developmentIndex: {
         feature: (developmentIndex?.feature as unknown[]) || [],

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

@@ -23,7 +23,7 @@
  * - POST   /api/queue/reorder       - Reorder queue items
  */
 import { readFileSync, existsSync, writeFileSync, mkdirSync, unlinkSync } from 'fs';
-import { join } from 'path';
+import { join, resolve, normalize } from 'path';
 import type { RouteContext } from './types.js';
 
 // ========== JSONL Helper Functions ==========
@@ -67,6 +67,12 @@ function readIssueHistoryJsonl(issuesDir: string): any[] {
   }
 }
 
+function writeIssueHistoryJsonl(issuesDir: string, issues: any[]) {
+  if (!existsSync(issuesDir)) mkdirSync(issuesDir, { recursive: true });
+  const historyPath = join(issuesDir, 'issue-history.jsonl');
+  writeFileSync(historyPath, issues.map(i => JSON.stringify(i)).join('\n'));
+}
+
 function writeSolutionsJsonl(issuesDir: string, issueId: string, solutions: any[]) {
   const solutionsDir = join(issuesDir, 'solutions');
   if (!existsSync(solutionsDir)) mkdirSync(solutionsDir, { recursive: true });
@@ -156,7 +162,30 @@ function writeQueue(issuesDir: string, queue: any) {
 
 function getIssueDetail(issuesDir: string, issueId: string) {
   const issues = readIssuesJsonl(issuesDir);
-  const issue = issues.find(i => i.id === issueId);
+  let issue = issues.find(i => i.id === issueId);
+
+  // Fallback: Reconstruct issue from solution file if issue not in issues.jsonl
+  if (!issue) {
+    const solutionPath = join(issuesDir, 'solutions', `${issueId}.jsonl`);
+    if (existsSync(solutionPath)) {
+      const solutions = readSolutionsJsonl(issuesDir, issueId);
+      if (solutions.length > 0) {
+        const boundSolution = solutions.find(s => s.is_bound) || solutions[0];
+        issue = {
+          id: issueId,
+          title: boundSolution?.description || issueId,
+          status: 'completed',
+          priority: 3,
+          context: boundSolution?.approach || '',
+          bound_solution_id: boundSolution?.id || null,
+          created_at: boundSolution?.created_at || new Date().toISOString(),
+          updated_at: new Date().toISOString(),
+          _reconstructed: true
+        };
+      }
+    }
+  }
+
   if (!issue) return null;
 
   const solutions = readSolutionsJsonl(issuesDir, issueId);
@@ -254,11 +283,46 @@ function bindSolutionToIssue(issuesDir: string, issueId: string, solutionId: str
   return { success: true, bound: solutionId };
 }
 
+// ========== Path Validation ==========
+
+/**
+ * Validate that the provided path is safe (no path traversal)
+ * Returns the resolved, normalized path or null if invalid
+ */
+function validateProjectPath(requestedPath: string, basePath: string): string | null {
+  if (!requestedPath) return basePath;
+
+  // Resolve to absolute path and normalize
+  const resolvedPath = resolve(normalize(requestedPath));
+  const resolvedBase = resolve(normalize(basePath));
+
+  // For local development tool, we allow any absolute path
+  // but prevent obvious traversal attempts
+  if (requestedPath.includes('..') && !resolvedPath.startsWith(resolvedBase)) {
+    // Check if it's trying to escape with ..
+    const normalizedRequested = normalize(requestedPath);
+    if (normalizedRequested.startsWith('..')) {
+      return null;
+    }
+  }
+
+  return resolvedPath;
+}
+
 // ========== Route Handler ==========
 
 export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
   const { pathname, url, req, res, initialPath, handlePostRequest } = ctx;
-  const projectPath = url.searchParams.get('path') || initialPath;
+  const rawProjectPath = url.searchParams.get('path') || initialPath;
+
+  // Validate project path to prevent path traversal
+  const projectPath = validateProjectPath(rawProjectPath, initialPath);
+  if (!projectPath) {
+    res.writeHead(400, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Invalid project path' }));
+    return true;
+  }
+
   const issuesDir = join(projectPath, '.workflow', 'issues');
 
   // ===== Queue Routes (top-level /api/queue) =====
@@ -295,7 +359,8 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
 
   // GET /api/queue/:id - Get specific queue by ID
   const queueDetailMatch = pathname.match(/^\/api\/queue\/([^/]+)$/);
-  if (queueDetailMatch && req.method === 'GET' && queueDetailMatch[1] !== 'history' && queueDetailMatch[1] !== 'reorder') {
+  const reservedQueuePaths = ['history', 'reorder', 'switch', 'deactivate', 'merge'];
+  if (queueDetailMatch && req.method === 'GET' && !reservedQueuePaths.includes(queueDetailMatch[1])) {
     const queueId = queueDetailMatch[1];
     const queuesDir = join(issuesDir, 'queues');
     const queueFilePath = join(queuesDir, `${queueId}.json`);
@@ -347,6 +412,29 @@ 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') {
+    handlePostRequest(req, res, async (body: any) => {
+      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: [] };
+
+        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 };
+      } catch (err) {
+        return { error: 'Failed to deactivate queue' };
+      }
+    });
+    return true;
+  }
+
   // POST /api/queue/reorder - Reorder queue items (supports both solutions and tasks)
   if (pathname === '/api/queue/reorder' && req.method === 'POST') {
     handlePostRequest(req, res, async (body: any) => {
@@ -399,6 +487,237 @@ 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\/([^/]+)$/);
+  if (queueItemDeleteMatch && req.method === 'DELETE') {
+    const queueId = queueItemDeleteMatch[1];
+    const itemId = decodeURIComponent(queueItemDeleteMatch[2]);
+
+    const queuesDir = join(issuesDir, 'queues');
+    const queueFilePath = join(queuesDir, `${queueId}.json`);
+
+    if (!existsSync(queueFilePath)) {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: `Queue ${queueId} not found` }));
+      return true;
+    }
+
+    try {
+      const queue = JSON.parse(readFileSync(queueFilePath, 'utf8'));
+      const items = queue.solutions || queue.tasks || [];
+      const filteredItems = items.filter((item: any) => item.item_id !== itemId);
+
+      if (filteredItems.length === items.length) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: `Item ${itemId} not found in queue` }));
+        return true;
+      }
+
+      // Update queue items
+      if (queue.solutions) {
+        queue.solutions = filteredItems;
+      } else {
+        queue.tasks = filteredItems;
+      }
+
+      // Recalculate metadata
+      const completedCount = filteredItems.filter((i: any) => i.status === 'completed').length;
+      queue._metadata = {
+        ...queue._metadata,
+        updated_at: new Date().toISOString(),
+        ...(queue.solutions
+          ? { total_solutions: filteredItems.length, completed_solutions: completedCount }
+          : { total_tasks: filteredItems.length, completed_tasks: completedCount })
+      };
+
+      writeFileSync(queueFilePath, JSON.stringify(queue, null, 2));
+
+      // Update index counts
+      const indexPath = join(queuesDir, 'index.json');
+      if (existsSync(indexPath)) {
+        try {
+          const index = JSON.parse(readFileSync(indexPath, 'utf8'));
+          const queueEntry = index.queues?.find((q: any) => q.id === queueId);
+          if (queueEntry) {
+            if (queue.solutions) {
+              queueEntry.total_solutions = filteredItems.length;
+              queueEntry.completed_solutions = completedCount;
+            } else {
+              queueEntry.total_tasks = filteredItems.length;
+              queueEntry.completed_tasks = completedCount;
+            }
+            writeFileSync(indexPath, JSON.stringify(index, null, 2));
+          }
+        } catch (err) {
+          console.error('Failed to update queue index:', err);
+        }
+      }
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ success: true, queueId, deletedItemId: itemId }));
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Failed to delete item' }));
+    }
+    return true;
+  }
+
+  // DELETE /api/queue/:queueId - Delete entire queue
+  const queueDeleteMatch = pathname.match(/^\/api\/queue\/([^/]+)$/);
+  if (queueDeleteMatch && req.method === 'DELETE') {
+    const queueId = queueDeleteMatch[1];
+    const queuesDir = join(issuesDir, 'queues');
+    const queueFilePath = join(queuesDir, `${queueId}.json`);
+    const indexPath = join(queuesDir, 'index.json');
+
+    if (!existsSync(queueFilePath)) {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: `Queue ${queueId} not found` }));
+      return true;
+    }
+
+    try {
+      // Delete queue file
+      unlinkSync(queueFilePath);
+
+      // Update index
+      if (existsSync(indexPath)) {
+        const index = JSON.parse(readFileSync(indexPath, 'utf8'));
+
+        // Remove from queues array
+        index.queues = (index.queues || []).filter((q: any) => q.id !== queueId);
+
+        // Clear active if this was the active queue
+        if (index.active_queue_id === queueId) {
+          index.active_queue_id = null;
+        }
+
+        writeFileSync(indexPath, JSON.stringify(index, null, 2));
+      }
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ success: true, deletedQueueId: queueId }));
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Failed to delete queue' }));
+    }
+    return true;
+  }
+
+  // POST /api/queue/merge - Merge source queue into target queue
+  if (pathname === '/api/queue/merge' && req.method === 'POST') {
+    handlePostRequest(req, res, async (body: any) => {
+      const { sourceQueueId, targetQueueId } = body;
+      if (!sourceQueueId || !targetQueueId) {
+        return { error: 'sourceQueueId and targetQueueId required' };
+      }
+
+      if (sourceQueueId === targetQueueId) {
+        return { error: 'Cannot merge queue into itself' };
+      }
+
+      const queuesDir = join(issuesDir, 'queues');
+      const sourcePath = join(queuesDir, `${sourceQueueId}.json`);
+      const targetPath = join(queuesDir, `${targetQueueId}.json`);
+
+      if (!existsSync(sourcePath)) return { error: `Source queue ${sourceQueueId} not found` };
+      if (!existsSync(targetPath)) return { error: `Target queue ${targetQueueId} not found` };
+
+      try {
+        const sourceQueue = JSON.parse(readFileSync(sourcePath, 'utf8'));
+        const targetQueue = JSON.parse(readFileSync(targetPath, 'utf8'));
+
+        const sourceItems = sourceQueue.solutions || sourceQueue.tasks || [];
+        const targetItems = targetQueue.solutions || targetQueue.tasks || [];
+        const isSolutionBased = !!targetQueue.solutions;
+
+        // Re-index source items to avoid ID conflicts
+        const maxOrder = targetItems.reduce((max: number, i: any) => Math.max(max, i.execution_order || 0), 0);
+        const reindexedSourceItems = sourceItems.map((item: any, idx: number) => ({
+          ...item,
+          item_id: `${item.item_id}-merged`,
+          execution_order: maxOrder + idx + 1,
+          execution_group: item.execution_group ? `M-${item.execution_group}` : 'M-ungrouped'
+        }));
+
+        // Merge items
+        const mergedItems = [...targetItems, ...reindexedSourceItems];
+
+        if (isSolutionBased) {
+          targetQueue.solutions = mergedItems;
+        } else {
+          targetQueue.tasks = mergedItems;
+        }
+
+        // Merge issue_ids
+        const mergedIssueIds = [...new Set([
+          ...(targetQueue.issue_ids || []),
+          ...(sourceQueue.issue_ids || [])
+        ])];
+        targetQueue.issue_ids = mergedIssueIds;
+
+        // Update metadata
+        const completedCount = mergedItems.filter((i: any) => i.status === 'completed').length;
+        targetQueue._metadata = {
+          ...targetQueue._metadata,
+          updated_at: new Date().toISOString(),
+          ...(isSolutionBased
+            ? { total_solutions: mergedItems.length, completed_solutions: completedCount }
+            : { total_tasks: mergedItems.length, completed_tasks: completedCount })
+        };
+
+        // Write merged queue
+        writeFileSync(targetPath, JSON.stringify(targetQueue, null, 2));
+
+        // Update source queue status
+        sourceQueue.status = 'merged';
+        sourceQueue._metadata = {
+          ...sourceQueue._metadata,
+          merged_into: targetQueueId,
+          merged_at: new Date().toISOString()
+        };
+        writeFileSync(sourcePath, JSON.stringify(sourceQueue, null, 2));
+
+        // Update index
+        const indexPath = join(queuesDir, 'index.json');
+        if (existsSync(indexPath)) {
+          try {
+            const index = JSON.parse(readFileSync(indexPath, 'utf8'));
+            const sourceEntry = index.queues?.find((q: any) => q.id === sourceQueueId);
+            const targetEntry = index.queues?.find((q: any) => q.id === targetQueueId);
+            if (sourceEntry) {
+              sourceEntry.status = 'merged';
+            }
+            if (targetEntry) {
+              if (isSolutionBased) {
+                targetEntry.total_solutions = mergedItems.length;
+                targetEntry.completed_solutions = completedCount;
+              } else {
+                targetEntry.total_tasks = mergedItems.length;
+                targetEntry.completed_tasks = completedCount;
+              }
+              targetEntry.issue_ids = mergedIssueIds;
+            }
+            writeFileSync(indexPath, JSON.stringify(index, null, 2));
+          } catch {
+            // Ignore index update errors
+          }
+        }
+
+        return {
+          success: true,
+          sourceQueueId,
+          targetQueueId,
+          mergedItemCount: sourceItems.length,
+          totalItems: mergedItems.length
+        };
+      } catch (err) {
+        return { error: 'Failed to merge queues' };
+      }
+    });
+    return true;
+  }
+
   // Legacy: GET /api/issues/queue (backward compat)
   if (pathname === '/api/issues/queue' && req.method === 'GET') {
     const queue = groupQueueByExecutionGroup(readQueue(issuesDir));
@@ -546,6 +865,39 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
     return true;
   }
 
+  // POST /api/issues/:id/archive - Archive issue (move to history)
+  const archiveMatch = pathname.match(/^\/api\/issues\/([^/]+)\/archive$/);
+  if (archiveMatch && req.method === 'POST') {
+    const issueId = decodeURIComponent(archiveMatch[1]);
+
+    const issues = readIssuesJsonl(issuesDir);
+    const issueIndex = issues.findIndex(i => i.id === issueId);
+
+    if (issueIndex === -1) {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Issue not found' }));
+      return true;
+    }
+
+    // Get the issue and add archive metadata
+    const issue = issues[issueIndex];
+    issue.archived_at = new Date().toISOString();
+    issue.status = 'completed';
+
+    // Move to history
+    const history = readIssueHistoryJsonl(issuesDir);
+    history.push(issue);
+    writeIssueHistoryJsonl(issuesDir, history);
+
+    // Remove from active issues
+    issues.splice(issueIndex, 1);
+    writeIssuesJsonl(issuesDir, issues);
+
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ success: true, issueId, archivedAt: issue.archived_at }));
+    return true;
+  }
+
   // POST /api/issues/:id/solutions - Add solution
   const addSolMatch = pathname.match(/^\/api\/issues\/([^/]+)\/solutions$/);
   if (addSolMatch && req.method === 'POST') {

ccw/src/templates/dashboard-css/32-issue-manager.css

@@ -429,14 +429,16 @@
   border: 1px solid hsl(var(--border));
   border-radius: 0.75rem;
   overflow: hidden;
+  margin-bottom: 1rem;
+  box-shadow: 0 1px 3px hsl(var(--foreground) / 0.04);
 }
 
 .queue-group-header {
   display: flex;
   align-items: center;
   justify-content: space-between;
-  padding: 0.75rem 1rem;
-  background: hsl(var(--muted) / 0.5);
+  padding: 0.875rem 1.25rem;
+  background: hsl(var(--muted) / 0.3);
   border-bottom: 1px solid hsl(var(--border));
 }
 
@@ -1256,6 +1258,68 @@
   color: hsl(var(--destructive));
 }
 
+/* Search Highlight */
+.search-highlight {
+  background: hsl(45 93% 47% / 0.3);
+  color: inherit;
+  padding: 0 2px;
+  border-radius: 2px;
+  font-weight: 500;
+}
+
+/* Search Suggestions Dropdown */
+.search-suggestions {
+  position: absolute;
+  top: 100%;
+  left: 0;
+  right: 0;
+  margin-top: 0.25rem;
+  background: hsl(var(--card));
+  border: 1px solid hsl(var(--border));
+  border-radius: 0.5rem;
+  box-shadow: 0 4px 12px hsl(var(--foreground) / 0.1);
+  max-height: 300px;
+  overflow-y: auto;
+  z-index: 50;
+  display: none;
+}
+
+.search-suggestions.show {
+  display: block;
+}
+
+.search-suggestion-item {
+  padding: 0.625rem 0.875rem;
+  cursor: pointer;
+  border-bottom: 1px solid hsl(var(--border) / 0.5);
+  transition: background 0.15s ease;
+}
+
+.search-suggestion-item:hover,
+.search-suggestion-item.selected {
+  background: hsl(var(--muted));
+}
+
+.search-suggestion-item:last-child {
+  border-bottom: none;
+}
+
+.suggestion-id {
+  font-family: var(--font-mono);
+  font-size: 0.7rem;
+  color: hsl(var(--muted-foreground));
+  margin-bottom: 0.125rem;
+}
+
+.suggestion-title {
+  font-size: 0.8125rem;
+  color: hsl(var(--foreground));
+  line-height: 1.3;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
 /* ==========================================
    CREATE BUTTON
    ========================================== */
@@ -1780,61 +1844,147 @@
 }
 
 .queue-items {
-  padding: 0.75rem;
+  padding: 1rem;
   display: flex;
   flex-direction: column;
-  gap: 0.5rem;
+  gap: 0.75rem;
 }
 
+/* Parallel items use CSS Grid for uniform sizing */
 .queue-items.parallel {
-  flex-direction: row;
-  flex-wrap: wrap;
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(130px, 1fr));
+  gap: 0.75rem;
 }
 
 .queue-items.parallel .queue-item {
-  flex: 1;
-  min-width: 200px;
+  display: grid;
+  grid-template-areas:
+    "id id delete"
+    "issue issue issue"
+    "solution solution solution";
+  grid-template-columns: 1fr 1fr auto;
+  grid-template-rows: auto auto 1fr;
+  align-items: start;
+  padding: 0.75rem;
+  min-height: 90px;
+  gap: 0.25rem;
+}
+
+/* Card content layout */
+.queue-items.parallel .queue-item .queue-item-id {
+  grid-area: id;
+  font-size: 0.875rem;
+  font-weight: 700;
+  color: hsl(var(--foreground));
+}
+
+.queue-items.parallel .queue-item .queue-item-issue {
+  grid-area: issue;
+  font-size: 0.6875rem;
+  color: hsl(var(--muted-foreground));
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  line-height: 1.3;
+}
+
+.queue-items.parallel .queue-item .queue-item-solution {
+  grid-area: solution;
+  display: flex;
+  align-items: center;
+  gap: 0.25rem;
+  font-size: 0.75rem;
+  font-weight: 500;
+  color: hsl(var(--foreground));
+  align-self: end;
+}
+
+/* Hide extra elements in parallel view */
+.queue-items.parallel .queue-item .queue-item-files,
+.queue-items.parallel .queue-item .queue-item-priority,
+.queue-items.parallel .queue-item .queue-item-deps,
+.queue-items.parallel .queue-item .queue-item-task {
+  display: none;
+}
+
+/* Delete button positioned in corner */
+.queue-items.parallel .queue-item .queue-item-delete {
+  grid-area: delete;
+  justify-self: end;
+  padding: 0.125rem;
+  opacity: 0;
 }
 
 .queue-group-type {
-  display: flex;
+  display: inline-flex;
   align-items: center;
   gap: 0.375rem;
   font-size: 0.875rem;
   font-weight: 600;
+  padding: 0.25rem 0.625rem;
+  border-radius: 0.375rem;
 }
 
 .queue-group-type.parallel {
-  color: hsl(142 71% 45%);
+  color: hsl(142 71% 40%);
+  background: hsl(142 71% 45% / 0.1);
 }
 
 .queue-group-type.sequential {
-  color: hsl(262 83% 58%);
+  color: hsl(262 83% 50%);
+  background: hsl(262 83% 58% / 0.1);
 }
 
-/* Queue Item Status Colors */
+/* Queue Item Status Colors - Enhanced visual distinction */
+
+/* Pending - Default subtle state */
+.queue-item.pending,
+.queue-item:not(.ready):not(.executing):not(.completed):not(.failed):not(.blocked) {
+  border-color: hsl(var(--border));
+  background: hsl(var(--card));
+}
+
+/* Ready - Blue tint, ready to execute */
 .queue-item.ready {
   border-color: hsl(199 89% 48%);
+  background: hsl(199 89% 48% / 0.06);
+  border-left: 3px solid hsl(199 89% 48%);
 }
 
+/* Executing - Amber with pulse animation */
 .queue-item.executing {
-  border-color: hsl(45 93% 47%);
-  background: hsl(45 93% 47% / 0.05);
+  border-color: hsl(38 92% 50%);
+  background: hsl(38 92% 50% / 0.08);
+  border-left: 3px solid hsl(38 92% 50%);
+  animation: executing-pulse 2s ease-in-out infinite;
 }
 
+@keyframes executing-pulse {
+  0%, 100% { box-shadow: 0 0 0 0 hsl(38 92% 50% / 0.3); }
+  50% { box-shadow: 0 0 8px 2px hsl(38 92% 50% / 0.2); }
+}
+
+/* Completed - Green success state */
 .queue-item.completed {
-  border-color: hsl(var(--success));
-  background: hsl(var(--success) / 0.05);
+  border-color: hsl(142 71% 45%);
+  background: hsl(142 71% 45% / 0.06);
+  border-left: 3px solid hsl(142 71% 45%);
 }
 
+/* Failed - Red error state */
 .queue-item.failed {
-  border-color: hsl(var(--destructive));
-  background: hsl(var(--destructive) / 0.05);
+  border-color: hsl(0 84% 60%);
+  background: hsl(0 84% 60% / 0.06);
+  border-left: 3px solid hsl(0 84% 60%);
 }
 
+/* Blocked - Purple/violet blocked state */
 .queue-item.blocked {
   border-color: hsl(262 83% 58%);
-  opacity: 0.7;
+  background: hsl(262 83% 58% / 0.05);
+  border-left: 3px solid hsl(262 83% 58%);
+  opacity: 0.8;
 }
 
 /* Priority indicator */
@@ -2236,61 +2386,89 @@
   flex-direction: column;
   align-items: center;
   justify-content: center;
-  padding: 0.75rem 1rem;
-  background: hsl(var(--muted) / 0.3);
+  padding: 1rem 1.25rem;
+  background: hsl(var(--card));
   border: 1px solid hsl(var(--border));
-  border-radius: 0.5rem;
+  border-radius: 0.75rem;
   text-align: center;
+  transition: all 0.2s ease;
+}
+
+.queue-stat-card:hover {
+  transform: translateY(-1px);
+  box-shadow: 0 2px 8px hsl(var(--foreground) / 0.06);
 }
 
 .queue-stat-card .queue-stat-value {
-  font-size: 1.5rem;
+  font-size: 1.75rem;
   font-weight: 700;
   color: hsl(var(--foreground));
   line-height: 1.2;
 }
 
 .queue-stat-card .queue-stat-label {
-  font-size: 0.75rem;
+  font-size: 0.6875rem;
   color: hsl(var(--muted-foreground));
   text-transform: uppercase;
-  letter-spacing: 0.025em;
-  margin-top: 0.25rem;
+  letter-spacing: 0.05em;
+  margin-top: 0.375rem;
+  font-weight: 500;
 }
 
+/* Pending - Slate/Gray with subtle blue tint */
 .queue-stat-card.pending {
-  border-color: hsl(var(--muted-foreground) / 0.3);
+  border-color: hsl(215 20% 65% / 0.4);
+  background: linear-gradient(135deg, hsl(215 20% 95%) 0%, hsl(var(--card)) 100%);
 }
 
 .queue-stat-card.pending .queue-stat-value {
-  color: hsl(var(--muted-foreground));
+  color: hsl(215 20% 45%);
 }
 
+.queue-stat-card.pending .queue-stat-label {
+  color: hsl(215 20% 55%);
+}
+
+/* Executing - Amber/Orange - attention-grabbing */
 .queue-stat-card.executing {
-  border-color: hsl(45 93% 47% / 0.5);
-  background: hsl(45 93% 47% / 0.05);
+  border-color: hsl(38 92% 50% / 0.5);
+  background: linear-gradient(135deg, hsl(38 92% 95%) 0%, hsl(45 93% 97%) 100%);
 }
 
 .queue-stat-card.executing .queue-stat-value {
-  color: hsl(45 93% 47%);
+  color: hsl(38 92% 40%);
 }
 
+.queue-stat-card.executing .queue-stat-label {
+  color: hsl(38 70% 45%);
+}
+
+/* Completed - Green - success indicator */
 .queue-stat-card.completed {
-  border-color: hsl(var(--success) / 0.5);
-  background: hsl(var(--success) / 0.05);
+  border-color: hsl(142 71% 45% / 0.5);
+  background: linear-gradient(135deg, hsl(142 71% 95%) 0%, hsl(142 50% 97%) 100%);
 }
 
 .queue-stat-card.completed .queue-stat-value {
-  color: hsl(var(--success));
+  color: hsl(142 71% 35%);
 }
 
+.queue-stat-card.completed .queue-stat-label {
+  color: hsl(142 50% 40%);
+}
+
+/* Failed - Red - error indicator */
 .queue-stat-card.failed {
-  border-color: hsl(var(--destructive) / 0.5);
-  background: hsl(var(--destructive) / 0.05);
+  border-color: hsl(0 84% 60% / 0.5);
+  background: linear-gradient(135deg, hsl(0 84% 95%) 0%, hsl(0 70% 97%) 100%);
 }
 
 .queue-stat-card.failed .queue-stat-value {
-  color: hsl(var(--destructive));
+  color: hsl(0 84% 45%);
+}
+
+.queue-stat-card.failed .queue-stat-label {
+  color: hsl(0 60% 50%);
 }
 
 /* ==========================================
@@ -2874,3 +3052,251 @@
     gap: 0.25rem;
   }
 }
+
+/* ==========================================
+   MULTI-QUEUE CARDS VIEW
+   ========================================== */
+
+/* Queue Cards Header */
+.queue-cards-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  flex-wrap: wrap;
+  gap: 1rem;
+}
+
+/* Queue Cards Grid */
+.queue-cards-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
+  gap: 1rem;
+  margin-bottom: 1.5rem;
+}
+
+/* Individual Queue Card */
+.queue-card {
+  position: relative;
+  background: hsl(var(--card));
+  border: 1px solid hsl(var(--border));
+  border-radius: 0.75rem;
+  padding: 1rem;
+  cursor: pointer;
+  transition: all 0.2s ease;
+}
+
+.queue-card:hover {
+  border-color: hsl(var(--primary) / 0.5);
+  transform: translateY(-2px);
+  box-shadow: 0 4px 12px hsl(var(--foreground) / 0.08);
+}
+
+.queue-card.active {
+  border-color: hsl(var(--primary));
+  background: hsl(var(--primary) / 0.05);
+}
+
+.queue-card.merged {
+  opacity: 0.6;
+  border-style: dashed;
+}
+
+.queue-card.merged:hover {
+  opacity: 0.8;
+}
+
+/* Queue Card Header */
+.queue-card-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  margin-bottom: 0.75rem;
+}
+
+.queue-card-id {
+  font-size: 0.875rem;
+  font-weight: 600;
+  color: hsl(var(--foreground));
+}
+
+.queue-card-badges {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+
+/* Queue Card Stats - Progress Bar */
+.queue-card-stats {
+  margin-bottom: 0.75rem;
+}
+
+.queue-card-stats .progress-bar {
+  height: 6px;
+  background: hsl(var(--muted));
+  border-radius: 3px;
+  overflow: hidden;
+  margin-bottom: 0.5rem;
+}
+
+.queue-card-stats .progress-fill {
+  height: 100%;
+  background: hsl(var(--primary));
+  border-radius: 3px;
+  transition: width 0.3s ease;
+}
+
+.queue-card-stats .progress-fill.completed {
+  background: hsl(var(--success, 142 76% 36%));
+}
+
+.queue-card-progress {
+  display: flex;
+  justify-content: space-between;
+  font-size: 0.75rem;
+  color: hsl(var(--foreground));
+}
+
+/* Queue Card Meta */
+.queue-card-meta {
+  display: flex;
+  gap: 1rem;
+  font-size: 0.75rem;
+  color: hsl(var(--muted-foreground));
+  margin-bottom: 0.75rem;
+}
+
+/* Queue Card Actions */
+.queue-card-actions {
+  display: flex;
+  gap: 0.5rem;
+  padding-top: 0.75rem;
+  border-top: 1px solid hsl(var(--border));
+}
+
+/* Queue Detail Header */
+.queue-detail-header {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  flex-wrap: wrap;
+}
+
+.queue-detail-title {
+  flex: 1;
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+}
+
+.queue-detail-actions {
+  display: flex;
+  gap: 0.5rem;
+}
+
+/* Queue Item Delete Button */
+.queue-item-delete {
+  margin-left: auto;
+  padding: 0.25rem;
+  opacity: 0;
+  transition: opacity 0.15s ease;
+  color: hsl(var(--muted-foreground));
+  border-radius: 0.25rem;
+}
+
+.queue-item:hover .queue-item-delete {
+  opacity: 1;
+}
+
+.queue-item-delete:hover {
+  color: hsl(var(--destructive, 0 84% 60%));
+  background: hsl(var(--destructive, 0 84% 60%) / 0.1);
+}
+
+/* Queue Error State */
+.queue-error {
+  padding: 2rem;
+  text-align: center;
+}
+
+/* Responsive adjustments for queue cards */
+@media (max-width: 640px) {
+  .queue-cards-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .queue-cards-header {
+    flex-direction: column;
+    align-items: flex-start;
+  }
+
+  .queue-detail-header {
+    flex-direction: column;
+    align-items: flex-start;
+  }
+
+  .queue-detail-title {
+    flex-direction: column;
+    align-items: flex-start;
+    gap: 0.5rem;
+  }
+}
+
+/* ==========================================
+   WARNING BUTTON STYLE
+   ========================================== */
+
+.btn-warning,
+.btn-secondary.btn-warning {
+  color: hsl(38 92% 40%);
+  border-color: hsl(38 92% 50% / 0.5);
+  background: hsl(38 92% 50% / 0.08);
+}
+
+.btn-warning:hover,
+.btn-secondary.btn-warning:hover {
+  background: hsl(38 92% 50% / 0.15);
+  border-color: hsl(38 92% 50%);
+}
+
+.btn-danger,
+.btn-secondary.btn-danger,
+.btn-sm.btn-danger {
+  color: hsl(var(--destructive));
+  border-color: hsl(var(--destructive) / 0.5);
+  background: hsl(var(--destructive) / 0.08);
+}
+
+.btn-danger:hover,
+.btn-secondary.btn-danger:hover,
+.btn-sm.btn-danger:hover {
+  background: hsl(var(--destructive) / 0.15);
+  border-color: hsl(var(--destructive));
+}
+
+/* Issue Detail Actions */
+.issue-detail-actions {
+  margin-top: 1rem;
+  padding-top: 1rem;
+  border-top: 1px solid hsl(var(--border));
+}
+
+.issue-detail-actions .flex {
+  display: flex;
+  gap: 0.5rem;
+  flex-wrap: wrap;
+}
+
+/* Active queue badge enhancement */
+.queue-active-badge {
+  display: inline-flex;
+  align-items: center;
+  padding: 0.125rem 0.5rem;
+  font-size: 0.6875rem;
+  font-weight: 600;
+  color: hsl(142 71% 35%);
+  background: hsl(142 71% 45% / 0.15);
+  border: 1px solid hsl(142 71% 45% / 0.3);
+  border-radius: 9999px;
+  text-transform: uppercase;
+  letter-spacing: 0.025em;
+}

ccw/src/templates/dashboard-js/i18n.js

@@ -2269,6 +2269,25 @@ const i18n = {
     'issues.queueCommandInfo': 'After running the command, click "Refresh" to see the updated queue.',
     'issues.alternative': 'Alternative',
     'issues.refreshAfter': 'Refresh Queue',
+    'issues.activate': 'Activate',
+    'issues.deactivate': 'Deactivate',
+    'issues.queueActivated': 'Queue activated',
+    'issues.queueDeactivated': 'Queue deactivated',
+    'issues.deleteQueue': 'Delete queue',
+    'issues.confirmDeleteQueue': 'Are you sure you want to delete this queue? This action cannot be undone.',
+    'issues.queueDeleted': 'Queue deleted successfully',
+    'issues.actions': 'Actions',
+    'issues.archive': 'Archive',
+    'issues.delete': 'Delete',
+    'issues.confirmDeleteIssue': 'Are you sure you want to delete this issue? This action cannot be undone.',
+    'issues.confirmArchiveIssue': 'Archive this issue? It will be moved to history.',
+    'issues.issueDeleted': 'Issue deleted successfully',
+    'issues.issueArchived': 'Issue archived successfully',
+    'issues.executionQueues': 'Execution Queues',
+    'issues.queues': 'queues',
+    'issues.noQueues': 'No queues found',
+    'issues.queueEmptyHint': 'Generate execution queue from bound solutions',
+    'issues.refresh': 'Refresh',
     // issue.* keys (legacy)
     'issue.viewIssues': 'Issues',
     'issue.viewQueue': 'Queue',
@@ -4592,6 +4611,25 @@ const i18n = {
     'issues.queueCommandInfo': '运行命令后，点击"刷新"查看更新后的队列。',
     'issues.alternative': '或者',
     'issues.refreshAfter': '刷新队列',
+    'issues.activate': '激活',
+    'issues.deactivate': '取消激活',
+    'issues.queueActivated': '队列已激活',
+    'issues.queueDeactivated': '队列已取消激活',
+    'issues.deleteQueue': '删除队列',
+    'issues.confirmDeleteQueue': '确定要删除此队列吗？此操作无法撤销。',
+    'issues.queueDeleted': '队列删除成功',
+    'issues.actions': '操作',
+    'issues.archive': '归档',
+    'issues.delete': '删除',
+    'issues.confirmDeleteIssue': '确定要删除此议题吗？此操作无法撤销。',
+    'issues.confirmArchiveIssue': '归档此议题？它将被移动到历史记录中。',
+    'issues.issueDeleted': '议题删除成功',
+    'issues.issueArchived': '议题归档成功',
+    'issues.executionQueues': '执行队列',
+    'issues.queues': '个队列',
+    'issues.noQueues': '暂无队列',
+    'issues.queueEmptyHint': '从绑定的解决方案生成执行队列',
+    'issues.refresh': '刷新',
     // issue.* keys (legacy)
     'issue.viewIssues': '议题',
     'issue.viewQueue': '队列',

ccw/src/templates/dashboard-js/views/codexlens-manager.js

@@ -6381,12 +6381,12 @@ async function showWatcherControlModal() {
 
     // Get first indexed project path as default
     let defaultPath = '';
-    if (indexes.success && indexes.projects && indexes.projects.length > 0) {
-      // Sort by last_indexed desc and pick the most recent
-      const sorted = indexes.projects.sort((a, b) =>
-        new Date(b.last_indexed || 0) - new Date(a.last_indexed || 0)
+    if (indexes.success && indexes.indexes && indexes.indexes.length > 0) {
+      // Sort by lastModified desc and pick the most recent
+      const sorted = indexes.indexes.sort((a, b) =>
+        new Date(b.lastModified || 0) - new Date(a.lastModified || 0)
       );
-      defaultPath = sorted[0].source_root || '';
+      defaultPath = sorted[0].path || '';
     }
 
     const modalHtml = buildWatcherControlContent(status, defaultPath);

ccw/src/templates/dashboard-js/views/skills-manager.js

@@ -956,15 +956,13 @@ function renderSkillFileModal() {
         </div>
 
         <!-- Content -->
-        <div class="flex-1 overflow-hidden p-4">
+        <div class="flex-1 min-h-0 overflow-auto p-4">
           ${isEditing ? `
             <textarea id="skillFileContent"
                       class="w-full h-full min-h-[400px] px-4 py-3 bg-background border border-border rounded-lg text-sm font-mono focus:outline-none focus:ring-2 focus:ring-primary resize-none"
                       spellcheck="false">${escapeHtml(content)}</textarea>
           ` : `
-            <div class="w-full h-full min-h-[400px] overflow-auto">
-              <pre class="px-4 py-3 bg-muted/30 rounded-lg text-sm font-mono whitespace-pre-wrap break-words">${escapeHtml(content)}</pre>
-            </div>
+            <pre class="px-4 py-3 bg-muted/30 rounded-lg text-sm font-mono whitespace-pre-wrap break-words">${escapeHtml(content)}</pre>
           `}
         </div>
 

ccw/src/tools/cli-executor-core.ts

@@ -356,7 +356,7 @@ const ParamsSchema = z.object({
   model: z.string().optional(),
   cd: z.string().optional(),
   includeDirs: z.string().optional(),
-  timeout: z.number().default(0), // 0 = no internal timeout, controlled by external caller (e.g., bash timeout)
+  // timeout removed - controlled by external caller (bash timeout)
   resume: z.union([z.boolean(), z.string()]).optional(), // true = last, string = single ID or comma-separated IDs
   id: z.string().optional(), // Custom execution ID (e.g., IMPL-001-step1)
   noNative: z.boolean().optional(), // Force prompt concatenation instead of native resume
@@ -388,7 +388,7 @@ async function executeCliTool(
     throw new Error(`Invalid params: ${parsed.error.message}`);
   }
 
-  const { tool, prompt, mode, format, model, cd, includeDirs, timeout, resume, id: customId, noNative, category, parentExecutionId, outputFormat } = parsed.data;
+  const { tool, prompt, mode, format, model, cd, includeDirs, resume, id: customId, noNative, category, parentExecutionId, outputFormat } = parsed.data;
 
   // Validate and determine working directory early (needed for conversation lookup)
   let workingDir: string;
@@ -862,7 +862,6 @@ async function executeCliTool(
 
     let stdout = '';
     let stderr = '';
-    let timedOut = false;
 
     // Handle stdout
     child.stdout!.on('data', (data: Buffer) => {
@@ -924,18 +923,14 @@ async function executeCliTool(
       debugLog('CLOSE', `Process closed`, {
         exitCode: code,
         duration: `${duration}ms`,
-        timedOut,
         stdoutLength: stdout.length,
         stderrLength: stderr.length,
         outputUnitsCount: allOutputUnits.length
       });
 
       // Determine status - prioritize output content over exit code
-      let status: 'success' | 'error' | 'timeout' = 'success';
-      if (timedOut) {
-        status = 'timeout';
-        debugLog('STATUS', `Execution timed out after ${duration}ms`);
-      } else if (code !== 0) {
+      let status: 'success' | 'error' = 'success';
+      if (code !== 0) {
         // Non-zero exit code doesn't always mean failure
         // Check if there's valid output (AI response) - treat as success
         const hasValidOutput = stdout.trim().length > 0;
@@ -1169,25 +1164,8 @@ async function executeCliTool(
       reject(new Error(`Failed to spawn ${tool}: ${error.message}\n  Command: ${command} ${args.join(' ')}\n  Working Dir: ${workingDir}`));
     });
 
-    // Timeout handling (timeout=0 disables internal timeout, controlled by external caller)
-    let timeoutId: NodeJS.Timeout | null = null;
-    if (timeout > 0) {
-      timeoutId = setTimeout(() => {
-        timedOut = true;
-        child.kill('SIGTERM');
-        setTimeout(() => {
-          if (!child.killed) {
-            child.kill('SIGKILL');
-          }
-        }, 5000);
-      }, timeout);
-    }
-
-    child.on('close', () => {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-    });
+    // Timeout controlled by external caller (bash timeout)
+    // When parent process terminates, child will be cleaned up via process exit handler
   });
 }
 
@@ -1228,12 +1206,8 @@ Modes:
       includeDirs: {
         type: 'string',
         description: 'Additional directories (comma-separated). Maps to --include-directories for gemini/qwen, --add-dir for codex'
-      },
-      timeout: {
-        type: 'number',
-        description: 'Timeout in milliseconds (default: 0 = disabled, controlled by external caller)',
-        default: 0
       }
+      // timeout removed - controlled by external caller (bash timeout)
     },
     required: ['tool', 'prompt']
   }

codex-lens/src/codexlens/cli/commands.py

@@ -3645,6 +3645,84 @@ def index_status(
         console.print(f"  SPLADE encoder: {'[green]Yes[/green]' if splade_available else f'[red]No[/red] ({splade_err})'}")
 
 
+# ==================== Index Update Command ====================
+
+@index_app.command("update")
+def index_update(
+    file_path: Path = typer.Argument(..., exists=True, file_okay=True, dir_okay=False, help="Path to the file to update in the index."),
+    json_mode: bool = typer.Option(False, "--json", help="Output JSON response."),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable debug logging."),
+) -> None:
+    """Update the index for a single file incrementally.
+
+    This is a lightweight command designed for use in hooks (e.g., Claude Code PostToolUse).
+    It updates only the specified file without scanning the entire directory.
+
+    The file's parent directory must already be indexed via 'codexlens index init'.
+
+    Examples:
+        codexlens index update src/main.py           # Update single file
+        codexlens index update ./foo.ts --json       # JSON output for hooks
+    """
+    _configure_logging(verbose, json_mode)
+
+    from codexlens.watcher.incremental_indexer import IncrementalIndexer
+
+    registry: RegistryStore | None = None
+    indexer: IncrementalIndexer | None = None
+
+    try:
+        registry = RegistryStore()
+        registry.initialize()
+        mapper = PathMapper()
+        config = Config()
+
+        resolved_path = file_path.resolve()
+
+        # Check if project is indexed
+        source_root = mapper.get_project_root(resolved_path)
+        if not source_root or not registry.get_project(source_root):
+            error_msg = f"Project containing file is not indexed: {file_path}"
+            if json_mode:
+                print_json(success=False, error=error_msg)
+            else:
+                console.print(f"[red]Error:[/red] {error_msg}")
+                console.print("[dim]Run 'codexlens index init' on the project root first.[/dim]")
+            raise typer.Exit(code=1)
+
+        indexer = IncrementalIndexer(registry, mapper, config)
+        result = indexer._index_file(resolved_path)
+
+        if result.success:
+            if json_mode:
+                print_json(success=True, result={
+                    "path": str(result.path),
+                    "symbols_count": result.symbols_count,
+                    "status": "updated",
+                })
+            else:
+                console.print(f"[green]✓[/green] Updated index for [bold]{result.path.name}[/bold] ({result.symbols_count} symbols)")
+        else:
+            error_msg = result.error or f"Failed to update index for {file_path}"
+            if json_mode:
+                print_json(success=False, error=error_msg)
+            else:
+                console.print(f"[red]Error:[/red] {error_msg}")
+            raise typer.Exit(code=1)
+
+    except CodexLensError as exc:
+        if json_mode:
+            print_json(success=False, error=str(exc))
+        else:
+            console.print(f"[red]Update failed:[/red] {exc}")
+        raise typer.Exit(code=1)
+    finally:
+        if indexer:
+            indexer.close()
+        if registry:
+            registry.close()
+
+
 # ==================== Index All Command ====================
 
 @index_app.command("all")

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "claude-code-workflow",
-  "version": "6.3.23",
+  "version": "6.3.31",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-code-workflow",
-      "version": "6.3.23",
+      "version": "6.3.31",
       "license": "MIT",
       "dependencies": {
         "@modelcontextprotocol/sdk": "^1.0.4",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-workflow",
-  "version": "6.3.29",
+  "version": "6.3.31",
   "description": "JSON-driven multi-agent development framework with intelligent CLI orchestration (Gemini/Qwen/Codex), context-first architecture, and automated workflow execution",
   "type": "module",
   "main": "ccw/src/index.js",