claude-code-workflow 6.3.24 → 6.3.26

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

@@ -9,6 +9,15 @@ import { getCliToolsStatus } from '../../tools/cli-executor.js';
 import { checkVenvStatus, checkSemanticStatus } from '../../tools/codex-lens.js';
 import type { RouteContext } from './types.js';
 
+// Performance logging helper
+const PERF_LOG_ENABLED = process.env.CCW_PERF_LOG === '1' || true; // Enable by default for debugging
+function perfLog(label: string, startTime: number, extra?: Record<string, unknown>): void {
+  if (!PERF_LOG_ENABLED) return;
+  const duration = Date.now() - startTime;
+  const extraStr = extra ? ` | ${JSON.stringify(extra)}` : '';
+  console.log(`[PERF][Status] ${label}: ${duration}ms${extraStr}`);
+}
+
 /**
  * Check CCW installation status
  * Verifies that required workflow files are installed in user's home directory
@@ -62,16 +71,39 @@ export async function handleStatusRoutes(ctx: RouteContext): Promise<boolean> {
 
   // API: Aggregated Status (all statuses in one call)
   if (pathname === '/api/status/all') {
+    const totalStart = Date.now();
+    console.log('[PERF][Status] === /api/status/all START ===');
+
     try {
       // Check CCW installation status (sync, fast)
+      const ccwStart = Date.now();
       const ccwInstallStatus = checkCcwInstallStatus();
+      perfLog('checkCcwInstallStatus', ccwStart);
+
+      // Execute all status checks in parallel with individual timing
+      const cliStart = Date.now();
+      const codexStart = Date.now();
+      const semanticStart = Date.now();
 
-      // Execute all status checks in parallel
       const [cliStatus, codexLensStatus, semanticStatus] = await Promise.all([
-        getCliToolsStatus(),
-        checkVenvStatus(),
+        getCliToolsStatus().then(result => {
+          perfLog('getCliToolsStatus', cliStart, { toolCount: Object.keys(result).length });
+          return result;
+        }),
+        checkVenvStatus().then(result => {
+          perfLog('checkVenvStatus', codexStart, { ready: result.ready });
+          return result;
+        }),
         // Always check semantic status (will return available: false if CodexLens not ready)
-        checkSemanticStatus().catch(() => ({ available: false, backend: null }))
+        checkSemanticStatus()
+          .then(result => {
+            perfLog('checkSemanticStatus', semanticStart, { available: result.available });
+            return result;
+          })
+          .catch(() => {
+            perfLog('checkSemanticStatus (error)', semanticStart);
+            return { available: false, backend: null };
+          })
       ]);
 
       const response = {
@@ -82,10 +114,13 @@ export async function handleStatusRoutes(ctx: RouteContext): Promise<boolean> {
         timestamp: new Date().toISOString()
       };
 
+      perfLog('=== /api/status/all TOTAL ===', totalStart);
+
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify(response));
       return true;
     } catch (error) {
+      perfLog('=== /api/status/all ERROR ===', totalStart);
       console.error('[Status Routes] Error fetching aggregated status:', error);
       res.writeHead(500, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({ error: (error as Error).message }));

package/ccw/src/core/server.ts

@@ -42,6 +42,10 @@ import { randomBytes } from 'crypto';
 // Import health check service
 import { getHealthCheckService } from './services/health-check-service.js';
 
+// Import status check functions for warmup
+import { checkSemanticStatus, checkVenvStatus } from '../tools/codex-lens.js';
+import { getCliToolsStatus } from '../tools/cli-executor.js';
+
 import type { ServerConfig } from '../types/config.js';
 import type { PostRequestHandler } from './routes/types.js';
 
@@ -290,6 +294,56 @@ function setCsrfCookie(res: http.ServerResponse, token: string, maxAgeSeconds: n
   appendSetCookie(res, attributes.join('; '));
 }
 
+/**
+ * Warmup function to pre-populate caches on server startup
+ * This runs asynchronously and non-blocking after the server starts
+ */
+async function warmupCaches(initialPath: string): Promise<void> {
+  console.log('[WARMUP] Starting cache warmup...');
+  const startTime = Date.now();
+
+  // Run all warmup tasks in parallel for faster startup
+  const warmupTasks = [
+    // Warmup semantic status cache (Python process startup - can be slow first time)
+    (async () => {
+      const taskStart = Date.now();
+      try {
+        const semanticStatus = await checkSemanticStatus();
+        console.log(`[WARMUP] Semantic status: ${semanticStatus.available ? 'available' : 'not available'} (${Date.now() - taskStart}ms)`);
+      } catch (err) {
+        console.warn(`[WARMUP] Semantic status check failed: ${(err as Error).message}`);
+      }
+    })(),
+
+    // Warmup venv status cache
+    (async () => {
+      const taskStart = Date.now();
+      try {
+        const venvStatus = await checkVenvStatus();
+        console.log(`[WARMUP] Venv status: ${venvStatus.ready ? 'ready' : 'not ready'} (${Date.now() - taskStart}ms)`);
+      } catch (err) {
+        console.warn(`[WARMUP] Venv status check failed: ${(err as Error).message}`);
+      }
+    })(),
+
+    // Warmup CLI tools status cache
+    (async () => {
+      const taskStart = Date.now();
+      try {
+        const cliStatus = await getCliToolsStatus();
+        const availableCount = Object.values(cliStatus).filter(s => s.available).length;
+        const totalCount = Object.keys(cliStatus).length;
+        console.log(`[WARMUP] CLI tools status: ${availableCount}/${totalCount} available (${Date.now() - taskStart}ms)`);
+      } catch (err) {
+        console.warn(`[WARMUP] CLI tools status check failed: ${(err as Error).message}`);
+      }
+    })()
+  ];
+
+  await Promise.allSettled(warmupTasks);
+  console.log(`[WARMUP] Cache warmup complete (${Date.now() - startTime}ms total)`);
+}
+
 /**
  * Generate dashboard HTML with embedded CSS and JS
  */
@@ -650,6 +704,14 @@ export async function startServer(options: ServerOptions = {}): Promise<http.Ser
         console.warn('[Server] Failed to start health check service:', err);
       }
 
+      // Start cache warmup asynchronously (non-blocking)
+      // Uses setImmediate to not delay server startup response
+      setImmediate(() => {
+        warmupCaches(initialPath).catch((err) => {
+          console.warn('[WARMUP] Cache warmup failed:', err);
+        });
+      });
+
       resolve(server);
     });
     server.on('error', reject);

package/ccw/src/core/services/api-key-tester.ts

@@ -72,6 +72,10 @@ export async function testApiKeyConnection(
     return { valid: false, error: urlValidation.error };
   }
 
+  // Normalize apiBase: remove trailing slashes to prevent URL construction issues
+  // e.g., "https://api.openai.com/v1/" -> "https://api.openai.com/v1"
+  const normalizedApiBase = apiBase.replace(/\/+$/, '');
+
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), timeout);
   const startTime = Date.now();
@@ -80,7 +84,7 @@ export async function testApiKeyConnection(
     if (providerType === 'anthropic') {
       // Anthropic format: Use /v1/models endpoint (no cost, no model dependency)
       // This validates the API key without making a billable request
-      const response = await fetch(`${apiBase}/models`, {
+      const response = await fetch(`${normalizedApiBase}/models`, {
         method: 'GET',
         headers: {
           'x-api-key': apiKey,
@@ -114,8 +118,10 @@ export async function testApiKeyConnection(
 
       return { valid: false, error: errorMessage };
     } else {
-      // OpenAI-compatible format: GET /v1/models
-      const modelsUrl = apiBase.endsWith('/v1') ? `${apiBase}/models` : `${apiBase}/v1/models`;
+      // OpenAI-compatible format: GET /v{N}/models
+      // Detect if URL already ends with a version pattern like /v1, /v2, /v4, etc.
+      const hasVersionSuffix = /\/v\d+$/.test(normalizedApiBase);
+      const modelsUrl = hasVersionSuffix ? `${normalizedApiBase}/models` : `${normalizedApiBase}/v1/models`;
       const response = await fetch(modelsUrl, {
         method: 'GET',
         headers: {

package/ccw/src/templates/dashboard-css/21-cli-toolmgmt.css

@@ -304,6 +304,51 @@
   margin-top: 0;
 }
 
+/* Environment File Input Group */
+.env-file-input-group {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+
+.env-file-input-row {
+  display: flex;
+  gap: 0.5rem;
+  align-items: center;
+}
+
+.env-file-input-row .tool-config-input {
+  flex: 1;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 0.8125rem;
+  margin-top: 0;
+}
+
+.env-file-input-row .btn-sm {
+  flex-shrink: 0;
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
+  padding: 0.5rem 0.75rem;
+  font-size: 0.8125rem;
+  white-space: nowrap;
+}
+
+.env-file-hint {
+  display: flex;
+  align-items: center;
+  gap: 0.375rem;
+  font-size: 0.75rem;
+  color: hsl(var(--muted-foreground));
+  margin: 0;
+  padding: 0;
+}
+
+.env-file-hint i {
+  flex-shrink: 0;
+  opacity: 0.7;
+}
+
 .btn-ghost.text-destructive:hover {
   background: hsl(var(--destructive) / 0.1);
 }

package/ccw/src/templates/dashboard-js/components/cli-status.js

@@ -33,11 +33,14 @@ function initCliStatus() {
  * Load all statuses using aggregated endpoint (single API call)
  */
 async function loadAllStatuses() {
+  const totalStart = performance.now();
+  console.log('[PERF][Frontend] loadAllStatuses START');
+
   // 1. 尝试从缓存获取（预加载的数据）
   if (window.cacheManager) {
     const cached = window.cacheManager.get('all-status');
     if (cached) {
-      console.log('[CLI Status] Loaded all statuses from cache');
+      console.log(`[PERF][Frontend] Cache hit: ${(performance.now() - totalStart).toFixed(1)}ms`);
       // 应用缓存数据
       cliToolStatus = cached.cli || {};
       codexLensStatus = cached.codexLens || { ready: false };
@@ -45,25 +48,32 @@ async function loadAllStatuses() {
       ccwInstallStatus = cached.ccwInstall || { installed: true, workflowsInstalled: true, missingFiles: [], installPath: '' };
 
       // Load CLI tools config, API endpoints, and CLI Settings（这些有自己的缓存）
+      const configStart = performance.now();
       await Promise.all([
         loadCliToolsConfig(),
         loadApiEndpoints(),
         loadCliSettingsEndpoints()
       ]);
+      console.log(`[PERF][Frontend] Config/Endpoints load: ${(performance.now() - configStart).toFixed(1)}ms`);
 
       // Update badges
       updateCliBadge();
       updateCodexLensBadge();
       updateCcwInstallBadge();
+
+      console.log(`[PERF][Frontend] loadAllStatuses TOTAL (cached): ${(performance.now() - totalStart).toFixed(1)}ms`);
       return cached;
     }
   }
 
   // 2. 缓存未命中，从服务器获取
   try {
+    const fetchStart = performance.now();
+    console.log('[PERF][Frontend] Fetching /api/status/all...');
     const response = await fetch('/api/status/all');
     if (!response.ok) throw new Error('Failed to load status');
     const data = await response.json();
+    console.log(`[PERF][Frontend] /api/status/all fetch: ${(performance.now() - fetchStart).toFixed(1)}ms`);
 
     // 存入缓存
     if (window.cacheManager) {
@@ -77,10 +87,11 @@ async function loadAllStatuses() {
     ccwInstallStatus = data.ccwInstall || { installed: true, workflowsInstalled: true, missingFiles: [], installPath: '' };
 
     // Load CLI tools config, API endpoints, and CLI Settings
-    await Promise.all([
-      loadCliToolsConfig(),
-      loadApiEndpoints(),
-      loadCliSettingsEndpoints()
+    const configStart = performance.now();
+    const [configResult, endpointsResult, settingsResult] = await Promise.all([
+      loadCliToolsConfig().then(r => { console.log(`[PERF][Frontend] loadCliToolsConfig: ${(performance.now() - configStart).toFixed(1)}ms`); return r; }),
+      loadApiEndpoints().then(r => { console.log(`[PERF][Frontend] loadApiEndpoints: ${(performance.now() - configStart).toFixed(1)}ms`); return r; }),
+      loadCliSettingsEndpoints().then(r => { console.log(`[PERF][Frontend] loadCliSettingsEndpoints: ${(performance.now() - configStart).toFixed(1)}ms`); return r; })
     ]);
 
     // Update badges
@@ -88,9 +99,11 @@ async function loadAllStatuses() {
     updateCodexLensBadge();
     updateCcwInstallBadge();
 
+    console.log(`[PERF][Frontend] loadAllStatuses TOTAL: ${(performance.now() - totalStart).toFixed(1)}ms`);
     return data;
   } catch (err) {
     console.error('Failed to load aggregated status:', err);
+    console.log(`[PERF][Frontend] loadAllStatuses ERROR after: ${(performance.now() - totalStart).toFixed(1)}ms`);
     // Fallback to individual calls if aggregated endpoint fails
     return await loadAllStatusesFallback();
   }
@@ -1034,6 +1047,15 @@ async function startCodexLensInstall() {
       progressBar.style.width = '100%';
       statusText.textContent = 'Installation complete!';
 
+      // 清理缓存以确保刷新后获取最新状态
+      if (window.cacheManager) {
+        window.cacheManager.invalidate('all-status');
+        window.cacheManager.invalidate('dashboard-init');
+      }
+      if (typeof window.invalidateCodexLensCache === 'function') {
+        window.invalidateCodexLensCache();
+      }
+
       setTimeout(() => {
         closeCodexLensInstallWizard();
         showRefreshToast('CodexLens installed successfully!', 'success');
@@ -1184,6 +1206,15 @@ async function startCodexLensUninstall() {
       progressBar.style.width = '100%';
       statusText.textContent = 'Uninstallation complete!';
 
+      // 清理缓存以确保刷新后获取最新状态
+      if (window.cacheManager) {
+        window.cacheManager.invalidate('all-status');
+        window.cacheManager.invalidate('dashboard-init');
+      }
+      if (typeof window.invalidateCodexLensCache === 'function') {
+        window.invalidateCodexLensCache();
+      }
+
       setTimeout(() => {
         closeCodexLensUninstallWizard();
         showRefreshToast('CodexLens uninstalled successfully!', 'success');

package/ccw/src/templates/dashboard-js/components/hook-manager.js

@@ -49,43 +49,17 @@ const HOOK_TEMPLATES = {
     description: 'Auto-update code index when files are written or edited',
     category: 'indexing'
   },
-  'memory-update-related': {
+  'memory-update-queue': {
     event: 'Stop',
     matcher: '',
     command: 'bash',
-    args: ['-c', 'ccw tool exec update_module_claude \'{"strategy":"related","tool":"gemini"}\''],
-    description: 'Update CLAUDE.md for changed modules when session ends',
+    args: ['-c', 'ccw tool exec memory_queue "{\\"action\\":\\"add\\",\\"path\\":\\"$CLAUDE_PROJECT_DIR\\"}"'],
+    description: 'Queue CLAUDE.md update when session ends (batched by threshold/timeout)',
     category: 'memory',
     configurable: true,
     config: {
-      tool: { type: 'select', options: ['gemini', 'qwen', 'codex'], default: 'gemini', label: 'CLI Tool' },
-      strategy: { type: 'select', options: ['related', 'single-layer'], default: 'related', label: 'Strategy' }
-    }
-  },
-  'memory-update-periodic': {
-    event: 'PostToolUse',
-    matcher: 'Write|Edit',
-    command: 'bash',
-    args: ['-c', 'INTERVAL=300; LAST_FILE="$HOME/.claude/.last_memory_update"; mkdir -p "$HOME/.claude"; NOW=$(date +%s); LAST=0; [ -f "$LAST_FILE" ] && LAST=$(cat "$LAST_FILE" 2>/dev/null || echo 0); if [ $((NOW - LAST)) -ge $INTERVAL ]; then echo $NOW > "$LAST_FILE"; ccw tool exec update_module_claude \'{"strategy":"related","tool":"gemini"}\' & fi'],
-    description: 'Periodically update CLAUDE.md (default: 5 min interval)',
-    category: 'memory',
-    configurable: true,
-    config: {
-      tool: { type: 'select', options: ['gemini', 'qwen', 'codex'], default: 'gemini', label: 'CLI Tool' },
-      interval: { type: 'number', default: 300, min: 60, max: 3600, label: 'Interval (seconds)', step: 60 }
-    }
-  },
-  'memory-update-count-based': {
-    event: 'PostToolUse',
-    matcher: 'Write|Edit',
-    command: 'bash',
-    args: ['-c', 'THRESHOLD=10; COUNT_FILE="$HOME/.claude/.memory_update_count"; mkdir -p "$HOME/.claude"; INPUT=$(cat); FILE_PATH=$(echo "$INPUT" | jq -r ".tool_input.file_path // .tool_input.path // empty" 2>/dev/null); [ -z "$FILE_PATH" ] && exit 0; COUNT=0; [ -f "$COUNT_FILE" ] && COUNT=$(cat "$COUNT_FILE" 2>/dev/null || echo 0); COUNT=$((COUNT + 1)); echo $COUNT > "$COUNT_FILE"; if [ $COUNT -ge $THRESHOLD ]; then echo 0 > "$COUNT_FILE"; ccw tool exec update_module_claude \'{"strategy":"related","tool":"gemini"}\' & fi'],
-    description: 'Update CLAUDE.md when file changes reach threshold (default: 10 files)',
-    category: 'memory',
-    configurable: true,
-    config: {
-      tool: { type: 'select', options: ['gemini', 'qwen', 'codex'], default: 'gemini', label: 'CLI Tool' },
-      threshold: { type: 'number', default: 10, min: 3, max: 50, label: 'File count threshold', step: 1 }
+      threshold: { type: 'number', default: 5, min: 1, max: 20, label: 'Threshold (paths)', step: 1 },
+      timeout: { type: 'number', default: 300, min: 60, max: 1800, label: 'Timeout (seconds)', step: 60 }
     }
   },
   // SKILL Context Loader templates
@@ -210,33 +184,19 @@ const HOOK_TEMPLATES = {
 const WIZARD_TEMPLATES = {
   'memory-update': {
     name: 'Memory Update Hook',
-    description: 'Automatically update CLAUDE.md documentation based on code changes',
+    description: 'Queue-based CLAUDE.md updates with configurable threshold and timeout',
     icon: 'brain',
     options: [
       {
-        id: 'on-stop',
-        name: 'On Session End',
-        description: 'Update documentation when Claude session ends',
-        templateId: 'memory-update-related'
-      },
-      {
-        id: 'periodic',
-        name: 'Periodic Update',
-        description: 'Update documentation at regular intervals during session',
-        templateId: 'memory-update-periodic'
-      },
-      {
-        id: 'count-based',
-        name: 'Count-Based Update',
-        description: 'Update documentation when file changes reach threshold',
-        templateId: 'memory-update-count-based'
+        id: 'queue',
+        name: 'Queue-Based Update',
+        description: 'Batch updates when threshold reached or timeout expires',
+        templateId: 'memory-update-queue'
       }
     ],
     configFields: [
-      { key: 'tool', type: 'select', label: 'CLI Tool', options: ['gemini', 'qwen', 'codex'], default: 'gemini', description: 'Tool for documentation generation' },
-      { key: 'interval', type: 'number', label: 'Interval (seconds)', default: 300, min: 60, max: 3600, step: 60, showFor: ['periodic'], description: 'Time between updates' },
-      { key: 'threshold', type: 'number', label: 'File Count Threshold', default: 10, min: 3, max: 50, step: 1, showFor: ['count-based'], description: 'Number of file changes to trigger update' },
-      { key: 'strategy', type: 'select', label: 'Update Strategy', options: ['related', 'single-layer'], default: 'related', description: 'Related: changed modules, Single-layer: current directory' }
+      { key: 'threshold', type: 'number', label: 'Threshold (paths)', default: 5, min: 1, max: 20, step: 1, description: 'Number of paths to trigger batch update' },
+      { key: 'timeout', type: 'number', label: 'Timeout (seconds)', default: 300, min: 60, max: 1800, step: 60, description: 'Auto-flush queue after this time' }
     ]
   },
   'skill-context': {
@@ -730,9 +690,7 @@ function renderWizardModalContent() {
   // Helper to get translated option names
   const getOptionName = (optId) => {
     if (wizardId === 'memory-update') {
-      if (optId === 'on-stop') return t('hook.wizard.onSessionEnd');
-      if (optId === 'periodic') return t('hook.wizard.periodicUpdate');
-      if (optId === 'count-based') return t('hook.wizard.countBasedUpdate');
+      if (optId === 'queue') return t('hook.wizard.queueBasedUpdate') || 'Queue-Based Update';
     }
     if (wizardId === 'memory-setup') {
       if (optId === 'file-read') return t('hook.wizard.fileReadTracker');
@@ -748,9 +706,7 @@ function renderWizardModalContent() {
 
   const getOptionDesc = (optId) => {
     if (wizardId === 'memory-update') {
-      if (optId === 'on-stop') return t('hook.wizard.onSessionEndDesc');
-      if (optId === 'periodic') return t('hook.wizard.periodicUpdateDesc');
-      if (optId === 'count-based') return t('hook.wizard.countBasedUpdateDesc');
+      if (optId === 'queue') return t('hook.wizard.queueBasedUpdateDesc') || 'Batch updates when threshold reached or timeout expires';
     }
     if (wizardId === 'memory-setup') {
       if (optId === 'file-read') return t('hook.wizard.fileReadTrackerDesc');
@@ -767,20 +723,16 @@ function renderWizardModalContent() {
   // Helper to get translated field labels
   const getFieldLabel = (fieldKey) => {
     const labels = {
-      'tool': t('hook.wizard.cliTool'),
-      'interval': t('hook.wizard.intervalSeconds'),
-      'threshold': t('hook.wizard.fileCountThreshold'),
-      'strategy': t('hook.wizard.updateStrategy')
+      'threshold': t('hook.wizard.thresholdPaths') || 'Threshold (paths)',
+      'timeout': t('hook.wizard.timeoutSeconds') || 'Timeout (seconds)'
     };
     return labels[fieldKey] || wizard.configFields.find(f => f.key === fieldKey)?.label || fieldKey;
   };
 
   const getFieldDesc = (fieldKey) => {
     const descs = {
-      'tool': t('hook.wizard.toolForDocGen'),
-      'interval': t('hook.wizard.timeBetweenUpdates'),
-      'threshold': t('hook.wizard.fileCountThresholdDesc'),
-      'strategy': t('hook.wizard.relatedStrategy')
+      'threshold': t('hook.wizard.thresholdPathsDesc') || 'Number of paths to trigger batch update',
+      'timeout': t('hook.wizard.timeoutSecondsDesc') || 'Auto-flush queue after this time'
     };
     return descs[fieldKey] || wizard.configFields.find(f => f.key === fieldKey)?.description || '';
   };
@@ -1154,21 +1106,10 @@ function generateWizardCommand() {
   }
 
   // Handle memory-update wizard (default)
-  const tool = wizardConfig.tool || 'gemini';
-  const strategy = wizardConfig.strategy || 'related';
-  const interval = wizardConfig.interval || 300;
-  const threshold = wizardConfig.threshold || 10;
-
-  // Build the ccw tool command based on configuration
-  const params = JSON.stringify({ strategy, tool });
-
-  if (triggerType === 'periodic') {
-    return `INTERVAL=${interval}; LAST_FILE="$HOME/.claude/.last_memory_update"; mkdir -p "$HOME/.claude"; NOW=$(date +%s); LAST=0; [ -f "$LAST_FILE" ] && LAST=$(cat "$LAST_FILE" 2>/dev/null || echo 0); if [ $((NOW - LAST)) -ge $INTERVAL ]; then echo $NOW > "$LAST_FILE"; ccw tool exec update_module_claude '${params}' & fi`;
-  } else if (triggerType === 'count-based') {
-    return `THRESHOLD=${threshold}; COUNT_FILE="$HOME/.claude/.memory_update_count"; mkdir -p "$HOME/.claude"; INPUT=$(cat); FILE_PATH=$(echo "$INPUT" | jq -r ".tool_input.file_path // .tool_input.path // empty" 2>/dev/null); [ -z "$FILE_PATH" ] && exit 0; COUNT=0; [ -f "$COUNT_FILE" ] && COUNT=$(cat "$COUNT_FILE" 2>/dev/null || echo 0); COUNT=$((COUNT + 1)); echo $COUNT > "$COUNT_FILE"; if [ $COUNT -ge $THRESHOLD ]; then echo 0 > "$COUNT_FILE"; ccw tool exec update_module_claude '${params}' & fi`;
-  } else {
-    return `ccw tool exec update_module_claude '${params}'`;
-  }
+  // Now uses memory_queue for batched updates with configurable threshold/timeout
+  // The command adds to queue, configuration is applied separately via submitHookWizard
+  const params = `"{\\"action\\":\\"add\\",\\"path\\":\\"$CLAUDE_PROJECT_DIR\\"}"`;
+  return `ccw tool exec memory_queue ${params}`;
 }
 
 async function submitHookWizard() {
@@ -1263,6 +1204,26 @@ async function submitHookWizard() {
   }
 
   await saveHook(scope, baseTemplate.event, hookData);
+
+  // For memory-update wizard, also configure queue settings
+  if (wizard.id === 'memory-update') {
+    const threshold = wizardConfig.threshold || 5;
+    const timeout = wizardConfig.timeout || 300;
+    try {
+      const configParams = JSON.stringify({ action: 'configure', threshold, timeout });
+      const response = await fetch('/api/tools/execute', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ tool: 'memory_queue', params: configParams })
+      });
+      if (response.ok) {
+        showRefreshToast(`Queue configured: threshold=${threshold}, timeout=${timeout}s`, 'success');
+      }
+    } catch (e) {
+      console.warn('Failed to configure memory queue:', e);
+    }
+  }
+
   closeHookWizardModal();
 }