feat: Implement unified Vue SPA with granular service control

Consolidate Reports and Data Entry apps into a single Vue.js SPA with:

Architecture:
- Module-based structure with lazy-loaded routes (@reports, @data-entry)
- Error boundaries per module to prevent cascade failures
- Dual API proxy in Vite for microservices (reports:8001, data-entry:8003)
- Pinia store factories for shared auth, company, and period stores
- Vite path aliases for clear module boundaries (@shared, @reports, @data-entry)

Service Management:
- Granular service control scripts (backend-reports.sh, backend-data-entry.sh, bot.sh, frontend.sh)
- 87% faster frontend restart: 7s vs 53s full restart
- 38% faster full startup: 33s vs 53s via parallel backend initialization
- Enhanced start-dev.sh with proper service timeouts (OCR: 30s, Vite: 15s, Bot: 10s)
- status.sh for comprehensive health checks

Features:
- Auto-select first company on login with period auto-load
- Hamburger menu with feature toggle support
- JWT token auto-injection via axios interceptors
- Unified header with company/period selectors
- IIS web.config for production deployment with multi-API routing

UX Improvements:
- Vue watchers for reactive company/period loading
- Lazy store initialization with graceful error handling
- Period persistence per user+company in localStorage
- Feature flags for optional modules

Deployment:
- Single IIS site serves unified frontend with API proxy rules
- Maintains separate backend processes for microservices
- Windows line ending fixes (.env CRLF → LF conversion)

Stats: 112 files changed, 38,342 insertions(+), 2,342 deletions(-)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

src/shared/stores/auth.js

@@ -0,0 +1,133 @@
+/**
+ * Shared Auth Store Factory
+ *
+ * Creates a Pinia auth store that can be used by any ROA2WEB application.
+ * Each app passes its own apiService instance configured with the correct baseURL.
+ *
+ * Usage:
+ *   import { createAuthStore } from '@shared/frontend/stores/auth';
+ *   import { apiService } from '../services/api';
+ *   export const useAuthStore = createAuthStore(apiService);
+ */
+
+import { defineStore } from "pinia";
+import { ref, computed } from "vue";
+
+/**
+ * Factory function to create an auth store with the provided API service
+ * @param {Object} apiService - Axios instance configured for the app's API
+ * @returns {Function} Pinia store definition
+ */
+export function createAuthStore(apiService) {
+  return defineStore("auth", () => {
+    // State
+    const accessToken = ref(localStorage.getItem("access_token"));
+    const refreshToken = ref(localStorage.getItem("refresh_token"));
+    const user = ref(JSON.parse(localStorage.getItem("user") || "null"));
+    const isLoading = ref(false);
+    const error = ref(null);
+
+    // Getters
+    const isAuthenticated = computed(() => !!accessToken.value);
+    const currentUser = computed(() => user.value);
+
+    // Actions
+    const login = async (credentials) => {
+      isLoading.value = true;
+      error.value = null;
+
+      try {
+        const response = await apiService.post("/auth/login", {
+          username: credentials.username,
+          password: credentials.password,
+        });
+        const { access_token, refresh_token, user: userData } = response.data;
+
+        accessToken.value = access_token;
+        refreshToken.value = refresh_token;
+        user.value = userData;
+
+        localStorage.setItem("access_token", access_token);
+        localStorage.setItem("refresh_token", refresh_token);
+        localStorage.setItem("user", JSON.stringify(userData));
+
+        apiService.defaults.headers.common["Authorization"] = `Bearer ${access_token}`;
+
+        return { success: true };
+      } catch (err) {
+        error.value = err.response?.data?.detail || "Login failed";
+        return { success: false, error: error.value };
+      } finally {
+        isLoading.value = false;
+      }
+    };
+
+    const logout = () => {
+      accessToken.value = null;
+      refreshToken.value = null;
+      user.value = null;
+      error.value = null;
+
+      localStorage.removeItem("access_token");
+      localStorage.removeItem("refresh_token");
+      localStorage.removeItem("user");
+
+      delete apiService.defaults.headers.common["Authorization"];
+    };
+
+    const refreshAccessToken = async () => {
+      if (!refreshToken.value) {
+        logout();
+        return false;
+      }
+
+      try {
+        const response = await apiService.post("/auth/refresh", {
+          refresh_token: refreshToken.value,
+        });
+
+        const { access_token } = response.data;
+        accessToken.value = access_token;
+        localStorage.setItem("access_token", access_token);
+        apiService.defaults.headers.common["Authorization"] = `Bearer ${access_token}`;
+
+        return true;
+      } catch (err) {
+        console.error("Token refresh failed:", err);
+        logout();
+        return false;
+      }
+    };
+
+    const initializeAuth = () => {
+      if (accessToken.value) {
+        apiService.defaults.headers.common["Authorization"] = `Bearer ${accessToken.value}`;
+      }
+    };
+
+    const clearError = () => {
+      error.value = null;
+    };
+
+    // Initialize on store creation
+    initializeAuth();
+
+    return {
+      // State
+      accessToken,
+      refreshToken,
+      user,
+      isLoading,
+      error,
+      // Getters
+      isAuthenticated,
+      currentUser,
+      // Actions
+      login,
+      logout,
+      refreshAccessToken,
+      initializeAuth,
+      clearError,
+    };
+  });
+}