claude-code-workflow 6.3.18 → 6.3.20

package/ccw/src/templates/dashboard-js/components/cli-stream-viewer.js

@@ -12,6 +12,82 @@ let searchFilter = '';  // Search filter for output content
 
 const MAX_OUTPUT_LINES = 5000;  // Prevent memory issues
 
+// ===== State Synchronization =====
+/**
+ * Sync active executions from server
+ * Called on initialization to recover state when view is opened mid-execution
+ */
+async function syncActiveExecutions() {
+  // Only sync in server mode
+  if (!window.SERVER_MODE) return;
+
+  try {
+    const response = await fetch('/api/cli/active');
+    if (!response.ok) return;
+
+    const { executions } = await response.json();
+    if (!executions || executions.length === 0) return;
+
+    executions.forEach(exec => {
+      // Skip if already tracked (avoid overwriting live data)
+      if (cliStreamExecutions[exec.id]) return;
+
+      // Rebuild execution state
+      cliStreamExecutions[exec.id] = {
+        tool: exec.tool || 'cli',
+        mode: exec.mode || 'analysis',
+        output: [],
+        status: exec.status || 'running',
+        startTime: exec.startTime || Date.now(),
+        endTime: null
+      };
+
+      // Add system start message
+      cliStreamExecutions[exec.id].output.push({
+        type: 'system',
+        content: `[${new Date(exec.startTime).toLocaleTimeString()}] CLI execution started: ${exec.tool} (${exec.mode} mode)`,
+        timestamp: exec.startTime
+      });
+
+      // Fill historical output (limit to last MAX_OUTPUT_LINES)
+      if (exec.output) {
+        const lines = exec.output.split('\n');
+        const startIndex = Math.max(0, lines.length - MAX_OUTPUT_LINES + 1);
+        lines.slice(startIndex).forEach(line => {
+          if (line.trim()) {
+            cliStreamExecutions[exec.id].output.push({
+              type: 'stdout',
+              content: line,
+              timestamp: Date.now()
+            });
+          }
+        });
+      }
+    });
+
+    // Update UI if we recovered any executions
+    if (executions.length > 0) {
+      // Set active tab to first running execution
+      const runningExec = executions.find(e => e.status === 'running');
+      if (runningExec && !activeStreamTab) {
+        activeStreamTab = runningExec.id;
+      }
+
+      renderStreamTabs();
+      updateStreamBadge();
+
+      // If viewer is open, render content
+      if (isCliStreamViewerOpen) {
+        renderStreamContent(activeStreamTab);
+      }
+    }
+
+    console.log(`[CLI Stream] Synced ${executions.length} active execution(s)`);
+  } catch (e) {
+    console.error('[CLI Stream] Sync failed:', e);
+  }
+}
+
 // ===== Initialization =====
 function initCliStreamViewer() {
   // Initialize keyboard shortcuts
@@ -39,6 +115,9 @@ function initCliStreamViewer() {
   if (content) {
     content.addEventListener('scroll', handleStreamContentScroll);
   }
+
+  // Sync active executions from server (recover state for mid-execution joins)
+  syncActiveExecutions();
 }
 
 // ===== Panel Control =====
@@ -107,37 +186,58 @@ function handleCliStreamStarted(payload) {
 }
 
 function handleCliStreamOutput(payload) {
-  const { executionId, chunkType, data } = payload;
-  
+  const { executionId, chunkType, data, unit } = payload;
+
   const exec = cliStreamExecutions[executionId];
   if (!exec) return;
-  
-  // Parse and add output lines
-  const content = typeof data === 'string' ? data : JSON.stringify(data);
+
+  // Use structured unit if available, otherwise fall back to data
+  const unitContent = unit?.content;
+  const unitType = unit?.type || chunkType;
+
+  // For tool_call type, format the content specially
+  let content;
+  if (unitType === 'tool_call' && typeof unitContent === 'object' && unitContent !== null) {
+    // Format tool_call for display
+    if (unitContent.action === 'invoke') {
+      const params = unitContent.parameters ? JSON.stringify(unitContent.parameters) : '';
+      content = `[Tool] ${unitContent.toolName}(${params})`;
+    } else if (unitContent.action === 'result') {
+      const status = unitContent.status || 'unknown';
+      const output = unitContent.output ? `: ${unitContent.output.substring(0, 200)}${unitContent.output.length > 200 ? '...' : ''}` : '';
+      content = `[Tool Result] ${status}${output}`;
+    } else {
+      content = JSON.stringify(unitContent);
+    }
+  } else {
+    // Use data (already serialized) for backward compatibility
+    content = typeof data === 'string' ? data : JSON.stringify(data);
+  }
+
   const lines = content.split('\n');
-  
+
   lines.forEach(line => {
     if (line.trim() || lines.length === 1) {  // Keep empty lines if it's the only content
       exec.output.push({
-        type: chunkType || 'stdout',
+        type: unitType || 'stdout',
         content: line,
         timestamp: Date.now()
       });
     }
   });
-  
+
   // Trim if too long
   if (exec.output.length > MAX_OUTPUT_LINES) {
     exec.output = exec.output.slice(-MAX_OUTPUT_LINES);
   }
-  
+
   // Update UI if this is the active tab
   if (activeStreamTab === executionId && isCliStreamViewerOpen) {
     requestAnimationFrame(() => {
       renderStreamContent(executionId);
     });
   }
-  
+
   // Update badge to show activity
   updateStreamBadge();
 }
@@ -190,6 +290,149 @@ function handleCliStreamError(payload) {
   updateStreamBadge();
 }
 
+// ===== Message Type Parsing =====
+const MESSAGE_TYPE_PATTERNS = {
+  system: /^\[系统\]/,
+  thinking: /^\[思考\]/,
+  response: /^\[响应\]/,
+  result: /^\[结果\]/,
+  error: /^\[错误\]/,
+  warning: /^\[警告\]/,
+  info: /^\[信息\]/
+};
+
+const MESSAGE_TYPE_ICONS = {
+  system: 'settings',
+  thinking: 'brain',
+  response: 'message-circle',
+  result: 'check-circle',
+  error: 'alert-circle',
+  warning: 'alert-triangle',
+  info: 'info'
+};
+
+const MESSAGE_TYPE_LABELS = {
+  system: '系统',
+  thinking: '思考',
+  response: '响应',
+  result: '结果',
+  error: '错误',
+  warning: '警告',
+  info: '信息'
+};
+
+/**
+ * Parse message content to extract type and clean content
+ * @param {string} content - Raw message content
+ * @returns {{ type: string, label: string, content: string, hasPrefix: boolean }}
+ */
+function parseMessageType(content) {
+  for (const [type, pattern] of Object.entries(MESSAGE_TYPE_PATTERNS)) {
+    if (pattern.test(content)) {
+      return {
+        type,
+        label: MESSAGE_TYPE_LABELS[type],
+        content: content.replace(pattern, '').trim(),
+        hasPrefix: true
+      };
+    }
+  }
+  return {
+    type: 'default',
+    label: '',
+    content: content,
+    hasPrefix: false
+  };
+}
+
+/**
+ * Render a formatted message line with type badge
+ * @param {Object} line - Line object with type and content
+ * @param {string} searchFilter - Current search filter
+ * @returns {string} - HTML string
+ */
+function renderFormattedLine(line, searchFilter) {
+  const parsed = parseMessageType(line.content);
+  let content = escapeHtml(parsed.content);
+
+  // Apply search highlighting
+  if (searchFilter && searchFilter.trim()) {
+    const searchRegex = new RegExp(`(${escapeRegex(searchFilter)})`, 'gi');
+    content = content.replace(searchRegex, '<mark class="cli-stream-highlight">$1</mark>');
+  }
+
+  // Format code blocks
+  content = formatCodeBlocks(content);
+
+  // Format inline code
+  content = content.replace(/`([^`]+)`/g, '<code class="cli-inline-code">$1</code>');
+
+  // Type badge icons for backend chunkType (CliOutputUnit.type)
+  // Maps to different CLI tools' output types:
+  // - Gemini: init→metadata, message→stdout, result→metadata, tool_use/tool_result→tool_call
+  // - Codex: reasoning→thought, agent_message→stdout, turn.completed→metadata
+  // - Claude: system→metadata, assistant→stdout, result→metadata
+  // - OpenCode: step_start→progress, text→stdout, step_finish→metadata
+  const CHUNK_TYPE_ICONS = {
+    thought: 'brain',
+    code: 'code',
+    file_diff: 'git-compare',
+    progress: 'loader',
+    system: 'settings',
+    stderr: 'alert-circle',
+    metadata: 'info',
+    stdout: 'message-circle',
+    tool_call: 'wrench'
+  };
+
+  // Type badge labels for backend chunkType
+  const CHUNK_TYPE_LABELS = {
+    thought: 'Thinking',
+    code: 'Code',
+    file_diff: 'Diff',
+    progress: 'Progress',
+    system: 'System',
+    stderr: 'Error',
+    metadata: 'Info',
+    stdout: 'Response',
+    tool_call: 'Tool'
+  };
+
+  // Build type badge - prioritize content prefix, then fall back to chunkType
+  let typeBadge = '';
+  let lineClass = '';
+
+  if (parsed.hasPrefix) {
+    // Content has Chinese prefix like [系统], [思考], etc.
+    typeBadge = `<span class="cli-msg-badge cli-msg-${parsed.type}">
+      <i data-lucide="${MESSAGE_TYPE_ICONS[parsed.type] || 'circle'}"></i>
+      <span>${parsed.label}</span>
+    </span>`;
+    lineClass = `cli-stream-line formatted ${parsed.type}`;
+  } else if (line.type && line.type !== 'stdout' && CHUNK_TYPE_LABELS[line.type]) {
+    // No content prefix, but backend sent a meaningful chunkType
+    typeBadge = `<span class="cli-msg-badge cli-msg-${line.type}">
+      <i data-lucide="${CHUNK_TYPE_ICONS[line.type] || 'circle'}"></i>
+      <span>${CHUNK_TYPE_LABELS[line.type]}</span>
+    </span>`;
+    lineClass = `cli-stream-line formatted ${line.type}`;
+  } else {
+    // Plain stdout, no badge
+    lineClass = `cli-stream-line ${line.type || 'stdout'}`;
+  }
+
+  return `<div class="${lineClass}">${typeBadge}<span class="cli-msg-content">${content}</span></div>`;
+}
+
+/**
+ * Format code blocks in content
+ */
+function formatCodeBlocks(content) {
+  // Handle multi-line code blocks (already escaped)
+  // Just apply styling class for now
+  return content;
+}
+
 // ===== UI Rendering =====
 function renderStreamTabs() {
   const tabsContainer = document.getElementById('cliStreamTabs');
@@ -272,16 +515,15 @@ function renderStreamContent(executionId) {
     );
   }
 
-  // Render output lines with search highlighting
-  contentContainer.innerHTML = filteredOutput.map(line => {
-    let content = escapeHtml(line.content);
-    // Highlight search matches
-    if (searchFilter.trim()) {
-      const searchRegex = new RegExp(`(${escapeRegex(searchFilter)})`, 'gi');
-      content = content.replace(searchRegex, '<mark class="cli-stream-highlight">$1</mark>');
-    }
-    return `<div class="cli-stream-line ${line.type}">${content}</div>`;
-  }).join('');
+  // Render output lines with formatted styling
+  contentContainer.innerHTML = filteredOutput.map(line =>
+    renderFormattedLine(line, searchFilter)
+  ).join('');
+
+  // Initialize Lucide icons for message badges
+  if (typeof lucide !== 'undefined') {
+    lucide.createIcons({ attrs: { class: 'cli-msg-icon' } });
+  }
 
   // Show filter result count if filtering
   if (searchFilter.trim() && filteredOutput.length !== exec.output.length) {

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

@@ -21,7 +21,7 @@ const HOOK_TEMPLATES = {
     event: 'PostToolUse',
     matcher: '',
     command: 'bash',
-    args: ['-c', 'INPUT=$(cat); TOOL=$(echo "$INPUT" | jq -r ".tool_name // empty"); FILE=$(echo "$INPUT" | jq -r ".tool_input.file_path // .tool_input.path // empty"); echo "[$(date)] Tool: $TOOL, File: $FILE" >> ~/.claude/tool-usage.log'],
+    args: ['-c', 'mkdir -p "$HOME/.claude"; INPUT=$(cat); TOOL=$(echo "$INPUT" | jq -r ".tool_name // empty" 2>/dev/null); FILE=$(echo "$INPUT" | jq -r ".tool_input.file_path // .tool_input.path // empty" 2>/dev/null); echo "[$(date)] Tool: $TOOL, File: $FILE" >> "$HOME/.claude/tool-usage.log"'],
     description: 'Log all tool executions to a file',
     category: 'logging'
   },
@@ -66,7 +66,7 @@ const HOOK_TEMPLATES = {
     event: 'PostToolUse',
     matcher: 'Write|Edit',
     command: 'bash',
-    args: ['-c', 'INTERVAL=300; LAST_FILE=~/.claude/.last_memory_update; NOW=$(date +%s); LAST=0; [ -f "$LAST_FILE" ] && LAST=$(cat "$LAST_FILE"); if [ $((NOW - LAST)) -ge $INTERVAL ]; then echo $NOW > "$LAST_FILE"; ccw tool exec update_module_claude \'{"strategy":"related","tool":"gemini"}\' & fi'],
+    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,
@@ -79,7 +79,7 @@ const HOOK_TEMPLATES = {
     event: 'PostToolUse',
     matcher: 'Write|Edit',
     command: 'bash',
-    args: ['-c', 'THRESHOLD=10; COUNT_FILE=~/.claude/.memory_update_count; INPUT=$(cat); FILE_PATH=$(echo "$INPUT" | jq -r ".tool_input.file_path // .tool_input.path // empty"); [ -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'],
+    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,
@@ -148,6 +148,61 @@ const HOOK_TEMPLATES = {
     description: 'Progressive session context (cluster overview → intent matching)',
     category: 'context',
     timeout: 5000
+  },
+  // ========== Danger Protection Hooks (PreToolUse with confirmation) ==========
+  'danger-bash-confirm': {
+    event: 'PreToolUse',
+    matcher: 'Bash',
+    command: 'bash',
+    args: ['-c', 'INPUT=$(cat); CMD=$(echo "$INPUT" | jq -r ".tool_input.command // empty"); DANGEROUS_PATTERNS="rm -rf|rmdir|del /|format |shutdown|reboot|kill -9|pkill|mkfs|dd if=|chmod 777|chown -R|>/dev/|wget.*\\|.*sh|curl.*\\|.*bash"; if echo "$CMD" | grep -qiE "$DANGEROUS_PATTERNS"; then echo "{\\"hookSpecificOutput\\":{\\"hookEventName\\":\\"PreToolUse\\",\\"permissionDecision\\":\\"ask\\",\\"permissionDecisionReason\\":\\"Potentially dangerous command detected: requires user confirmation\\"}}" && exit 0; fi; exit 0'],
+    description: 'Confirm before running potentially dangerous shell commands (rm -rf, shutdown, etc.)',
+    category: 'danger',
+    timeout: 5000
+  },
+  'danger-file-protection': {
+    event: 'PreToolUse',
+    matcher: 'Write|Edit',
+    command: 'bash',
+    args: ['-c', 'INPUT=$(cat); FILE=$(echo "$INPUT" | jq -r ".tool_input.file_path // .tool_input.path // empty"); PROTECTED=".env|.git/|package-lock.json|yarn.lock|.credentials|secrets|id_rsa|.pem$|.key$"; if echo "$FILE" | grep -qiE "$PROTECTED"; then echo "{\\"hookSpecificOutput\\":{\\"hookEventName\\":\\"PreToolUse\\",\\"permissionDecision\\":\\"deny\\",\\"permissionDecisionReason\\":\\"Protected file cannot be modified: $FILE\\"}}" && exit 0; fi; exit 0'],
+    description: 'Block modifications to sensitive files (.env, .git/, secrets, keys)',
+    category: 'danger',
+    timeout: 5000
+  },
+  'danger-git-destructive': {
+    event: 'PreToolUse',
+    matcher: 'Bash',
+    command: 'bash',
+    args: ['-c', 'INPUT=$(cat); CMD=$(echo "$INPUT" | jq -r ".tool_input.command // empty"); GIT_DANGEROUS="git push.*--force|git push.*-f|git reset --hard|git clean -fd|git checkout.*--force|git branch -D|git rebase.*-f"; if echo "$CMD" | grep -qiE "$GIT_DANGEROUS"; then echo "{\\"hookSpecificOutput\\":{\\"hookEventName\\":\\"PreToolUse\\",\\"permissionDecision\\":\\"ask\\",\\"permissionDecisionReason\\":\\"Destructive git operation detected: $CMD\\"}}" && exit 0; fi; exit 0'],
+    description: 'Confirm before destructive git operations (force push, hard reset, etc.)',
+    category: 'danger',
+    timeout: 5000
+  },
+  'danger-network-confirm': {
+    event: 'PreToolUse',
+    matcher: 'Bash|WebFetch',
+    command: 'bash',
+    args: ['-c', 'INPUT=$(cat); TOOL=$(echo "$INPUT" | jq -r ".tool_name // empty"); if [ "$TOOL" = "WebFetch" ]; then URL=$(echo "$INPUT" | jq -r ".tool_input.url // empty"); echo "{\\"hookSpecificOutput\\":{\\"hookEventName\\":\\"PreToolUse\\",\\"permissionDecision\\":\\"ask\\",\\"permissionDecisionReason\\":\\"Network request to: $URL\\"}}" && exit 0; fi; CMD=$(echo "$INPUT" | jq -r ".tool_input.command // empty"); NET_CMDS="curl|wget|nc |netcat|ssh |scp |rsync|ftp "; if echo "$CMD" | grep -qiE "^($NET_CMDS)"; then echo "{\\"hookSpecificOutput\\":{\\"hookEventName\\":\\"PreToolUse\\",\\"permissionDecision\\":\\"ask\\",\\"permissionDecisionReason\\":\\"Network command requires confirmation: $CMD\\"}}" && exit 0; fi; exit 0'],
+    description: 'Confirm before network operations (curl, wget, ssh, WebFetch)',
+    category: 'danger',
+    timeout: 5000
+  },
+  'danger-system-paths': {
+    event: 'PreToolUse',
+    matcher: 'Write|Edit|Bash',
+    command: 'bash',
+    args: ['-c', 'INPUT=$(cat); TOOL=$(echo "$INPUT" | jq -r ".tool_name // empty"); if [ "$TOOL" = "Bash" ]; then CMD=$(echo "$INPUT" | jq -r ".tool_input.command // empty"); SYS_PATHS="/etc/|/usr/|/bin/|/sbin/|/boot/|/sys/|/proc/|C:\\\\Windows|C:\\\\Program Files"; if echo "$CMD" | grep -qiE "$SYS_PATHS"; then echo "{\\"hookSpecificOutput\\":{\\"hookEventName\\":\\"PreToolUse\\",\\"permissionDecision\\":\\"ask\\",\\"permissionDecisionReason\\":\\"System path operation requires confirmation\\"}}" && exit 0; fi; else FILE=$(echo "$INPUT" | jq -r ".tool_input.file_path // .tool_input.path // empty"); SYS_PATHS="/etc/|/usr/|/bin/|/sbin/|C:\\\\Windows|C:\\\\Program Files"; if echo "$FILE" | grep -qiE "$SYS_PATHS"; then echo "{\\"hookSpecificOutput\\":{\\"hookEventName\\":\\"PreToolUse\\",\\"permissionDecision\\":\\"deny\\",\\"permissionDecisionReason\\":\\"Cannot modify system file: $FILE\\"}}" && exit 0; fi; fi; exit 0'],
+    description: 'Block/confirm operations on system directories (/etc, /usr, Windows)',
+    category: 'danger',
+    timeout: 5000
+  },
+  'danger-permission-change': {
+    event: 'PreToolUse',
+    matcher: 'Bash',
+    command: 'bash',
+    args: ['-c', 'INPUT=$(cat); CMD=$(echo "$INPUT" | jq -r ".tool_input.command // empty"); PERM_CMDS="chmod|chown|chgrp|setfacl|icacls|takeown|cacls"; if echo "$CMD" | grep -qiE "^($PERM_CMDS)"; then echo "{\\"hookSpecificOutput\\":{\\"hookEventName\\":\\"PreToolUse\\",\\"permissionDecision\\":\\"ask\\",\\"permissionDecisionReason\\":\\"Permission change requires confirmation: $CMD\\"}}" && exit 0; fi; exit 0'],
+    description: 'Confirm before changing file permissions (chmod, chown, icacls)',
+    category: 'danger',
+    timeout: 5000
   }
 };
 
@@ -232,6 +287,51 @@ const WIZARD_TEMPLATES = {
     ],
     configFields: [],
     multiSelect: true
+  },
+  'danger-protection': {
+    name: 'Danger Protection',
+    description: 'Protect against dangerous operations with confirmation dialogs',
+    icon: 'shield-alert',
+    options: [
+      {
+        id: 'bash-confirm',
+        name: 'Dangerous Commands',
+        description: 'Confirm before rm -rf, shutdown, kill, format, etc.',
+        templateId: 'danger-bash-confirm'
+      },
+      {
+        id: 'file-protection',
+        name: 'Sensitive Files',
+        description: 'Block modifications to .env, .git/, secrets, keys',
+        templateId: 'danger-file-protection'
+      },
+      {
+        id: 'git-destructive',
+        name: 'Git Operations',
+        description: 'Confirm force push, hard reset, branch delete',
+        templateId: 'danger-git-destructive'
+      },
+      {
+        id: 'network-confirm',
+        name: 'Network Access',
+        description: 'Confirm curl, wget, ssh, WebFetch requests',
+        templateId: 'danger-network-confirm'
+      },
+      {
+        id: 'system-paths',
+        name: 'System Paths',
+        description: 'Block/confirm operations on /etc, /usr, C:\\Windows',
+        templateId: 'danger-system-paths'
+      },
+      {
+        id: 'permission-change',
+        name: 'Permission Changes',
+        description: 'Confirm chmod, chown, icacls operations',
+        templateId: 'danger-permission-change'
+      }
+    ],
+    configFields: [],
+    multiSelect: true
   }
 };
 
@@ -1063,9 +1163,9 @@ function generateWizardCommand() {
   const params = JSON.stringify({ strategy, tool });
 
   if (triggerType === 'periodic') {
-    return `INTERVAL=${interval}; LAST_FILE=~/.claude/.last_memory_update; NOW=$(date +%s); LAST=0; [ -f "$LAST_FILE" ] && LAST=$(cat "$LAST_FILE"); if [ $((NOW - LAST)) -ge $INTERVAL ]; then echo $NOW > "$LAST_FILE"; ccw tool exec update_module_claude '${params}' & fi`;
+    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=~/.claude/.memory_update_count; INPUT=$(cat); FILE_PATH=$(echo "$INPUT" | jq -r ".tool_input.file_path // .tool_input.path // empty"); [ -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`;
+    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}'`;
   }