agileflow 2.91.0 → 2.92.0

package/scripts/archive-completed-stories.sh

@@ -5,12 +5,26 @@
 
 set -e
 
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
+# Source shared utilities
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Source colors from canonical source (lib/colors.sh)
+if [[ -f "$SCRIPT_DIR/lib/colors.sh" ]]; then
+  source "$SCRIPT_DIR/lib/colors.sh"
+  NC="$RESET"  # Alias for backwards compatibility
+else
+  # Fallback colors if colors.sh not available
+  RED='\033[0;31m'
+  GREEN='\033[0;32m'
+  YELLOW='\033[1;33m'
+  BLUE='\033[0;34m'
+  NC='\033[0m'
+fi
+
+# Source JSON utilities if available
+if [[ -f "$SCRIPT_DIR/lib/json-utils.sh" ]]; then
+  source "$SCRIPT_DIR/lib/json-utils.sh"
+fi
 
 # Default paths (relative to project root)
 DOCS_DIR="docs"
@@ -45,12 +59,17 @@ THRESHOLD_DAYS=7
 ENABLED=true
 
 if [[ -f "$METADATA_FILE" ]]; then
-  if command -v jq &> /dev/null; then
+  # Use safeJsonParse if available (from json-utils.sh), otherwise fallback
+  if declare -f safeJsonParse > /dev/null; then
+    ENABLED=$(safeJsonParse "$METADATA_FILE" ".archival.enabled" "true")
+    THRESHOLD_DAYS=$(safeJsonParse "$METADATA_FILE" ".archival.threshold_days" "7")
+  elif command -v jq &> /dev/null; then
     ENABLED=$(jq -r '.archival.enabled // true' "$METADATA_FILE")
     THRESHOLD_DAYS=$(jq -r '.archival.threshold_days // 7' "$METADATA_FILE")
   elif command -v node &> /dev/null; then
-    ENABLED=$(node -pe "JSON.parse(require('fs').readFileSync('$METADATA_FILE', 'utf8')).archival?.enabled ?? true")
-    THRESHOLD_DAYS=$(node -pe "JSON.parse(require('fs').readFileSync('$METADATA_FILE', 'utf8')).archival?.threshold_days ?? 7")
+    # Security: Pass file path via environment variable, not string interpolation
+    ENABLED=$(METADATA_PATH="$METADATA_FILE" node -pe "JSON.parse(require('fs').readFileSync(process.env.METADATA_PATH, 'utf8')).archival?.enabled ?? true" 2>/dev/null || echo "true")
+    THRESHOLD_DAYS=$(METADATA_PATH="$METADATA_FILE" node -pe "JSON.parse(require('fs').readFileSync(process.env.METADATA_PATH, 'utf8')).archival?.threshold_days ?? 7" 2>/dev/null || echo "7")
   fi
 fi
 
@@ -64,6 +83,15 @@ echo -e "${BLUE}Starting auto-archival (threshold: $THRESHOLD_DAYS days)...${NC}
 # Create archive directory if needed
 mkdir -p "$ARCHIVE_DIR"
 
+# Security: Validate archive directory is not a symlink pointing outside project
+if [[ -L "$ARCHIVE_DIR" ]]; then
+  RESOLVED_ARCHIVE=$(readlink -f "$ARCHIVE_DIR" 2>/dev/null || realpath "$ARCHIVE_DIR" 2>/dev/null)
+  if [[ ! "$RESOLVED_ARCHIVE" == "$PROJECT_ROOT"* ]]; then
+    echo -e "${RED}Error: Archive directory symlink points outside project. Aborting.${NC}"
+    exit 1
+  fi
+fi
+
 # Calculate cutoff date (threshold days ago)
 if [[ "$OSTYPE" == "darwin"* ]]; then
   # macOS
@@ -118,6 +146,12 @@ for (const [storyId, story] of Object.entries(toArchive)) {
   const date = new Date(story.completed_at);
   const monthKey = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;
 
+  // Security: Validate monthKey matches expected format (YYYY-MM) to prevent path traversal
+  if (!/^\d{4}-\d{2}$/.test(monthKey)) {
+    console.error(`\x1b[31mSkipping story ${storyId}: invalid date format\x1b[0m`);
+    continue;
+  }
+
   if (!byMonth[monthKey]) {
     byMonth[monthKey] = {
       month: monthKey,
@@ -133,10 +167,22 @@ for (const [storyId, story] of Object.entries(toArchive)) {
 for (const [monthKey, archiveData] of Object.entries(byMonth)) {
   const archiveFile = path.join(archiveDir, `${monthKey}.json`);
 
+  // Security: Verify resolved path stays within archive directory
+  const resolvedPath = path.resolve(archiveFile);
+  const resolvedArchiveDir = path.resolve(archiveDir);
+  if (!resolvedPath.startsWith(resolvedArchiveDir + path.sep) && resolvedPath !== resolvedArchiveDir) {
+    console.error(`\x1b[31mSecurity: Archive path ${archiveFile} escapes archive directory. Skipping.\x1b[0m`);
+    continue;
+  }
+
   // Merge with existing archive if it exists
   if (fs.existsSync(archiveFile)) {
-    const existing = JSON.parse(fs.readFileSync(archiveFile, 'utf8'));
-    archiveData.stories = { ...existing.stories, ...archiveData.stories };
+    try {
+      const existing = JSON.parse(fs.readFileSync(archiveFile, 'utf8'));
+      archiveData.stories = { ...existing.stories, ...archiveData.stories };
+    } catch (e) {
+      console.error(`\x1b[31mWarning: Could not parse existing ${monthKey}.json, will overwrite\x1b[0m`);
+    }
   }
 
   fs.writeFileSync(archiveFile, JSON.stringify(archiveData, null, 2));

package/scripts/claude-tmux.sh

@@ -0,0 +1,102 @@
+#!/bin/bash
+# claude-tmux.sh - Wrapper script that auto-starts Claude Code in a tmux session
+#
+# Usage:
+#   ./claude-tmux.sh              # Start in tmux with default session
+#   ./claude-tmux.sh --no-tmux    # Start without tmux (regular claude)
+#   ./claude-tmux.sh -n           # Same as --no-tmux
+#
+# When already in tmux: Just runs claude normally
+# When not in tmux: Creates a tmux session and runs claude inside it
+
+set -e
+
+# Check for --no-tmux flag
+NO_TMUX=false
+for arg in "$@"; do
+  case $arg in
+    --no-tmux|-n)
+      NO_TMUX=true
+      shift
+      ;;
+  esac
+done
+
+# If --no-tmux was specified, just run claude directly
+if [ "$NO_TMUX" = true ]; then
+  exec claude "$@"
+fi
+
+# Check if tmux auto-spawn is disabled in config
+METADATA_FILE="docs/00-meta/agileflow-metadata.json"
+if [ -f "$METADATA_FILE" ]; then
+  # Use node to parse JSON (more reliable than jq which may not be installed)
+  TMUX_ENABLED=$(node -e "
+    try {
+      const meta = JSON.parse(require('fs').readFileSync('$METADATA_FILE', 'utf8'));
+      // Default to true (enabled) if not explicitly set to false
+      console.log(meta.features?.tmuxAutoSpawn?.enabled !== false ? 'true' : 'false');
+    } catch (e) {
+      console.log('true');  // Default to enabled on error
+    }
+  " 2>/dev/null || echo "true")
+
+  if [ "$TMUX_ENABLED" = "false" ]; then
+    exec claude "$@"
+  fi
+fi
+
+# Check if we're already inside tmux
+if [ -n "$TMUX" ]; then
+  # Already in tmux, just run claude
+  exec claude "$@"
+fi
+
+# Check if tmux is available
+if ! command -v tmux &> /dev/null; then
+  echo "tmux not found. Running claude without tmux."
+  echo "Install tmux for parallel session support:"
+  echo "  macOS:        brew install tmux"
+  echo "  Ubuntu/Debian: sudo apt install tmux"
+  echo ""
+  exec claude "$@"
+fi
+
+# Generate session name based on current directory
+DIR_NAME=$(basename "$(pwd)")
+SESSION_NAME="claude-${DIR_NAME}"
+
+# Check if session already exists
+if tmux has-session -t "$SESSION_NAME" 2>/dev/null; then
+  echo "Attaching to existing session: $SESSION_NAME"
+  exec tmux attach-session -t "$SESSION_NAME"
+fi
+
+# Create new tmux session with Claude
+echo "Starting Claude in tmux session: $SESSION_NAME"
+
+# Create session in detached mode first
+tmux new-session -d -s "$SESSION_NAME" -n "main"
+
+# Minimal config - mouse and scrolling only, no fancy styling
+tmux set-option -t "$SESSION_NAME" mouse on
+
+# Fix colors - proper terminal support
+tmux set-option -t "$SESSION_NAME" default-terminal "xterm-256color"
+
+# Keybindings: Alt+number to switch windows, Alt+q to detach
+for i in 1 2 3 4 5 6 7 8 9; do
+  tmux bind-key -n "M-$i" select-window -t ":$((i-1))"
+done
+tmux bind-key -n M-q detach-client
+
+# Send the claude command to the first window
+CLAUDE_CMD="claude"
+if [ $# -gt 0 ]; then
+  # Pass any remaining arguments to claude
+  CLAUDE_CMD="claude $*"
+fi
+tmux send-keys -t "$SESSION_NAME" "$CLAUDE_CMD" Enter
+
+# Attach to the session
+exec tmux attach-session -t "$SESSION_NAME"

package/scripts/damage-control-bash.js

@@ -15,74 +15,7 @@
  * Usage: Configured as PreToolUse hook in .claude/settings.json
  */
 
-const {
-  findProjectRoot,
-  loadPatterns,
-  outputBlocked,
-  runDamageControlHook,
-  parseBashPatterns,
-  c,
-} = require('./lib/damage-control-utils');
+const { createBashHook } = require('./lib/damage-control-utils');
 
-/**
- * Test command against a single pattern rule
- */
-function matchesPattern(command, rule) {
-  try {
-    const flags = rule.flags || '';
-    const regex = new RegExp(rule.pattern, flags);
-    return regex.test(command);
-  } catch (e) {
-    // Invalid regex - skip this pattern
-    return false;
-  }
-}
-
-/**
- * Validate command against all patterns
- */
-function validateCommand(command, config) {
-  // Check blocked patterns (bashToolPatterns + agileflowProtections)
-  const blockedPatterns = [
-    ...(config.bashToolPatterns || []),
-    ...(config.agileflowProtections || []),
-  ];
-
-  for (const rule of blockedPatterns) {
-    if (matchesPattern(command, rule)) {
-      return {
-        action: 'block',
-        reason: rule.reason || 'Command blocked by damage control',
-      };
-    }
-  }
-
-  // Check ask patterns
-  for (const rule of config.askPatterns || []) {
-    if (matchesPattern(command, rule)) {
-      return {
-        action: 'ask',
-        reason: rule.reason || 'Please confirm this command',
-      };
-    }
-  }
-
-  // Allow by default
-  return { action: 'allow' };
-}
-
-// Run the hook
-const projectRoot = findProjectRoot();
-const defaultConfig = { bashToolPatterns: [], askPatterns: [], agileflowProtections: [] };
-
-runDamageControlHook({
-  getInputValue: input => input.command || input.tool_input?.command,
-  loadConfig: () => loadPatterns(projectRoot, parseBashPatterns, defaultConfig),
-  validate: validateCommand,
-  onBlock: (result, command) => {
-    outputBlocked(
-      result.reason,
-      `Command: ${command.substring(0, 100)}${command.length > 100 ? '...' : ''}`
-    );
-  },
-});
+// Run the hook using factory
+createBashHook()();

package/scripts/damage-control-edit.js

@@ -12,24 +12,7 @@
  * Usage: Configured as PreToolUse hook in .claude/settings.json
  */
 
-const {
-  findProjectRoot,
-  loadPatterns,
-  outputBlocked,
-  runDamageControlHook,
-  parsePathPatterns,
-  validatePathAgainstPatterns,
-} = require('./lib/damage-control-utils');
+const { createPathHook } = require('./lib/damage-control-utils');
 
-// Run the hook
-const projectRoot = findProjectRoot();
-const defaultConfig = { zeroAccessPaths: [], readOnlyPaths: [], noDeletePaths: [] };
-
-runDamageControlHook({
-  getInputValue: input => input.file_path || input.tool_input?.file_path,
-  loadConfig: () => loadPatterns(projectRoot, parsePathPatterns, defaultConfig),
-  validate: (filePath, config) => validatePathAgainstPatterns(filePath, config, 'edit'),
-  onBlock: (result, filePath) => {
-    outputBlocked(result.reason, result.detail, `File: ${filePath}`);
-  },
-});
+// Run the hook using factory
+createPathHook('edit')();

package/scripts/damage-control-write.js

@@ -12,24 +12,7 @@
  * Usage: Configured as PreToolUse hook in .claude/settings.json
  */
 
-const {
-  findProjectRoot,
-  loadPatterns,
-  outputBlocked,
-  runDamageControlHook,
-  parsePathPatterns,
-  validatePathAgainstPatterns,
-} = require('./lib/damage-control-utils');
+const { createPathHook } = require('./lib/damage-control-utils');
 
-// Run the hook
-const projectRoot = findProjectRoot();
-const defaultConfig = { zeroAccessPaths: [], readOnlyPaths: [], noDeletePaths: [] };
-
-runDamageControlHook({
-  getInputValue: input => input.file_path || input.tool_input?.file_path,
-  loadConfig: () => loadPatterns(projectRoot, parsePathPatterns, defaultConfig),
-  validate: (filePath, config) => validatePathAgainstPatterns(filePath, config, 'write'),
-  onBlock: (result, filePath) => {
-    outputBlocked(result.reason, result.detail, `File: ${filePath}`);
-  },
-});
+// Run the hook using factory
+createPathHook('write')();

package/scripts/dependency-check.js

@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+
+/**
+ * AgileFlow CLI - Dependency Check Script
+ *
+ * Local script for checking dependency vulnerabilities and generating reports.
+ * Can be run manually or integrated into CI/CD pipelines.
+ *
+ * Usage:
+ *   node scripts/dependency-check.js [options]
+ *
+ * Options:
+ *   --json         Output results as JSON
+ *   --fix          Attempt to auto-fix vulnerabilities
+ *   --force        Force fixes (may include breaking changes)
+ *   --severity=X   Minimum severity to report (low, moderate, high, critical)
+ *   --quiet        Only show errors
+ *   --help         Show help
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// ANSI colors
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+};
+
+const SEVERITY_LEVELS = ['low', 'moderate', 'high', 'critical'];
+
+/**
+ * Parse command line arguments
+ */
+function parseArgs(args) {
+  const options = {
+    json: false,
+    fix: false,
+    force: false,
+    severity: 'low',
+    quiet: false,
+    help: false,
+  };
+
+  for (const arg of args) {
+    if (arg === '--json') options.json = true;
+    else if (arg === '--fix') options.fix = true;
+    else if (arg === '--force') options.force = true;
+    else if (arg === '--quiet') options.quiet = true;
+    else if (arg === '--help' || arg === '-h') options.help = true;
+    else if (arg.startsWith('--severity=')) {
+      const level = arg.split('=')[1].toLowerCase();
+      if (SEVERITY_LEVELS.includes(level)) {
+        options.severity = level;
+      }
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Show help message
+ */
+function showHelp() {
+  console.log(`
+${c.bold}AgileFlow Dependency Check${c.reset}
+
+${c.cyan}Usage:${c.reset}
+  node scripts/dependency-check.js [options]
+
+${c.cyan}Options:${c.reset}
+  --json         Output results as JSON
+  --fix          Attempt to auto-fix vulnerabilities
+  --force        Force fixes (may include breaking changes)
+  --severity=X   Minimum severity to report (low, moderate, high, critical)
+  --quiet        Only show errors
+  --help, -h     Show this help message
+
+${c.cyan}Examples:${c.reset}
+  # Check for all vulnerabilities
+  node scripts/dependency-check.js
+
+  # Only report high and critical
+  node scripts/dependency-check.js --severity=high
+
+  # Auto-fix and output JSON
+  node scripts/dependency-check.js --fix --json
+
+  # Force all fixes
+  node scripts/dependency-check.js --fix --force
+`);
+}
+
+/**
+ * Run npm audit and parse results
+ */
+function runAudit() {
+  try {
+    const output = execSync('npm audit --json 2>&1', {
+      encoding: 'utf8',
+      maxBuffer: 10 * 1024 * 1024, // 10MB buffer for large outputs
+    });
+    return JSON.parse(output);
+  } catch (error) {
+    // npm audit exits with non-zero if vulnerabilities found
+    if (error.stdout) {
+      try {
+        return JSON.parse(error.stdout);
+      } catch {
+        return { error: error.message, metadata: { vulnerabilities: {} } };
+      }
+    }
+    return { error: error.message, metadata: { vulnerabilities: {} } };
+  }
+}
+
+/**
+ * Apply npm audit fix
+ */
+function runFix(force = false) {
+  const cmd = force
+    ? 'npm audit fix --force --legacy-peer-deps'
+    : 'npm audit fix --legacy-peer-deps';
+  try {
+    const output = execSync(cmd, { encoding: 'utf8', stdio: 'pipe' });
+    return { success: true, output };
+  } catch (error) {
+    return { success: false, error: error.message, output: error.stdout || '' };
+  }
+}
+
+/**
+ * Filter vulnerabilities by severity
+ */
+function filterBySeverity(audit, minSeverity) {
+  const minIndex = SEVERITY_LEVELS.indexOf(minSeverity);
+  const filtered = { ...audit };
+
+  if (audit.vulnerabilities) {
+    filtered.vulnerabilities = Object.fromEntries(
+      Object.entries(audit.vulnerabilities).filter(([, vuln]) => {
+        const vulnIndex = SEVERITY_LEVELS.indexOf(vuln.severity);
+        return vulnIndex >= minIndex;
+      })
+    );
+  }
+
+  return filtered;
+}
+
+/**
+ * Format audit results for console output
+ */
+function formatResults(audit, options) {
+  const { metadata = {}, vulnerabilities = {} } = audit;
+  const vulnCounts = metadata.vulnerabilities || {};
+
+  const lines = [];
+
+  // Header
+  lines.push(`\n${c.bold}Dependency Audit Report${c.reset}`);
+  lines.push(`${c.dim}${'─'.repeat(40)}${c.reset}\n`);
+
+  // Summary
+  const total = vulnCounts.total || 0;
+  if (total === 0) {
+    lines.push(`${c.green}✓ No vulnerabilities found!${c.reset}\n`);
+    return lines.join('\n');
+  }
+
+  lines.push(`${c.bold}Vulnerabilities Found: ${total}${c.reset}`);
+  lines.push('');
+
+  // By severity
+  if (vulnCounts.critical > 0) {
+    lines.push(`  ${c.red}● Critical: ${vulnCounts.critical}${c.reset}`);
+  }
+  if (vulnCounts.high > 0) {
+    lines.push(`  ${c.yellow}● High: ${vulnCounts.high}${c.reset}`);
+  }
+  if (vulnCounts.moderate > 0) {
+    lines.push(`  ${c.cyan}● Moderate: ${vulnCounts.moderate}${c.reset}`);
+  }
+  if (vulnCounts.low > 0) {
+    lines.push(`  ${c.dim}● Low: ${vulnCounts.low}${c.reset}`);
+  }
+  lines.push('');
+
+  // Details (if not quiet)
+  if (!options.quiet && Object.keys(vulnerabilities).length > 0) {
+    lines.push(`${c.bold}Details:${c.reset}`);
+    for (const [name, vuln] of Object.entries(vulnerabilities)) {
+      const severityColor =
+        vuln.severity === 'critical'
+          ? c.red
+          : vuln.severity === 'high'
+            ? c.yellow
+            : vuln.severity === 'moderate'
+              ? c.cyan
+              : c.dim;
+      lines.push(`  ${severityColor}[${vuln.severity.toUpperCase()}]${c.reset} ${name}`);
+      if (vuln.via && Array.isArray(vuln.via)) {
+        const vias = vuln.via.filter(v => typeof v === 'object').slice(0, 2);
+        for (const via of vias) {
+          if (via.title) {
+            lines.push(`    └─ ${via.title}`);
+          }
+        }
+      }
+    }
+    lines.push('');
+  }
+
+  // Recommendations
+  lines.push(`${c.bold}Recommendations:${c.reset}`);
+  lines.push('  Run: npm audit fix');
+  if (vulnCounts.critical > 0 || vulnCounts.high > 0) {
+    lines.push('  Or force: npm audit fix --force (may include breaking changes)');
+  }
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+
+  if (options.help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  if (!options.quiet && !options.json) {
+    console.log(`${c.cyan}Running dependency audit...${c.reset}`);
+  }
+
+  // Run audit
+  let audit = runAudit();
+
+  // Filter by severity
+  audit = filterBySeverity(audit, options.severity);
+
+  // Apply fix if requested
+  let fixResult = null;
+  if (options.fix) {
+    if (!options.quiet && !options.json) {
+      console.log(`${c.cyan}Applying fixes...${c.reset}`);
+    }
+    fixResult = runFix(options.force);
+  }
+
+  // Output results
+  if (options.json) {
+    const result = {
+      audit,
+      fix: fixResult,
+      timestamp: new Date().toISOString(),
+      severity_filter: options.severity,
+    };
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(formatResults(audit, options));
+    if (fixResult) {
+      if (fixResult.success) {
+        console.log(`${c.green}✓ Fixes applied successfully${c.reset}`);
+      } else {
+        console.log(`${c.yellow}⚠ Some fixes could not be applied${c.reset}`);
+      }
+    }
+  }
+
+  // Exit with appropriate code
+  const vulnCounts = audit.metadata?.vulnerabilities || {};
+  const total = vulnCounts.total || 0;
+  const hasHighSeverity = (vulnCounts.critical || 0) + (vulnCounts.high || 0) > 0;
+
+  if (hasHighSeverity) {
+    process.exit(2); // High/critical vulnerabilities
+  } else if (total > 0) {
+    process.exit(1); // Some vulnerabilities
+  }
+  process.exit(0); // All clear
+}
+
+// Run if called directly
+if (require.main === module) {
+  main().catch(error => {
+    console.error(`${c.red}Error: ${error.message}${c.reset}`);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  parseArgs,
+  runAudit,
+  runFix,
+  filterBySeverity,
+  formatResults,
+  SEVERITY_LEVELS,
+};

package/scripts/get-env.js

@@ -19,6 +19,12 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
+// Import centralized path utilities
+const { getStatusPath } = require('../lib/paths');
+
+// Import centralized file cache (US-0176: deduplicated status.json access)
+const { readJSONCached } = require('../lib/file-cache');
+
 function getProjectInfo() {
   const rootDir = path.resolve(__dirname, '..');
 
@@ -72,14 +78,15 @@ function getProjectInfo() {
   const activeEpics = [];
 
   try {
-    const statusPath = path.join(rootDir, 'docs/09-agents/status.json');
-    if (fs.existsSync(statusPath)) {
-      const status = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
+    const statusPath = getStatusPath(rootDir);
+    // Use centralized file cache (US-0176: 60s TTL, shared across all consumers)
+    const status = readJSONCached(statusPath, { ttlMs: 60000 });
 
+    if (status) {
       // Get active stories
       if (status.stories) {
         Object.entries(status.stories).forEach(([id, story]) => {
-          if (story.status === 'in_progress') {
+          if (story.status === 'in-progress') {
             activeStories.push({ id, title: story.title, owner: story.owner });
             wipCount++;
           }