1 State Registration Compliance Alert System

1.1 Overview

Automated monitoring system that tracks client counts by state and provides early warning alerts before reaching regulatory filing thresholds. Prevents account opening delays by ensuring required state paperwork is filed proactively.

1.2 Problem Statement

ECIC must file additional registration paperwork with state regulators when reaching specific client thresholds (e.g., 15 clients in California). Currently this creates account opening delays when limits are hit unexpectedly, with clients “waiting in line” until paperwork is processed.

1.3 Alert Architecture

graph TB
    A[New Client Onboarding] --> B[Extract State from Address]
    B --> C[Update Client Count by State]
    C --> D[Check Against Registration Limits]
    D --> E{Approaching Limit?}
    E -->|Yes| F[Generate Alert]
    E -->|No| G[Continue Onboarding]
    F --> H[Notify Admin + Create Filing Task]
    H --> I[Track Filing Status]

1.4 Core Monitoring System

1.4.1 API Endpoint: /api/compliance/state-registration-check

export default {
  async fetch(request, env) {
    if (request.url.includes('/api/compliance/state-registration-check')) {
      try {
        // Get current client counts by state
        const stateCounts = await getCurrentClientCountsByState(env);

        // Check against known limits
        const alerts = [];

        for (const [state, count] of Object.entries(stateCounts)) {
          const limit = getStateRegistrationLimit(state);
          const warningThreshold = limit - 3; // Alert 3 clients before limit

          if (count >= warningThreshold) {
            alerts.push({
              state: state,
              stateName: getStateName(state),
              currentCount: count,
              limit: limit,
              clientsRemaining: limit - count,
              urgency: count >= limit ? 'CRITICAL' : 'WARNING',
              actionRequired: count >= limit ? 'IMMEDIATE_FILING' : 'PREPARE_FILING',
              filingStatus: await getFilingStatus(state, env),
              estimatedProcessingTime: getStateProcessingTime(state)
            });
          }
        }

        return new Response(JSON.stringify({
          alerts: alerts,
          lastChecked: new Date().toISOString(),
          totalStates: Object.keys(stateCounts).length,
          totalClients: Object.values(stateCounts).reduce((a, b) => a + b, 0)
        }));

      } catch (error) {
        return new Response(JSON.stringify({
          error: error.message
        }), { status: 500 });
      }
    }
  }
};

// State registration limits (expand as needed)
function getStateRegistrationLimit(stateCode) {
  const limits = {
    'CA': 15, // California
    'NY': 20, // New York
    'TX': 25, // Texas
    'FL': 15, // Florida
    'PA': 20, // Pennsylvania
    'IL': 15, // Illinois
    // Add more states as ECIC expands
  };

  return limits[stateCode] || 5; // Default conservative limit
}

// Processing times for filing (in business days)
function getStateProcessingTime(stateCode) {
  const processingTimes = {
    'CA': '10-15 business days',
    'NY': '5-10 business days',
    'TX': '7-12 business days',
    'FL': '5-8 business days',
    'PA': '10-14 business days',
    'IL': '7-10 business days'
  };

  return processingTimes[stateCode] || '5-10 business days';
}

1.4.2 Client Count Tracking

async function getCurrentClientCountsByState(env) {
  // Query LACRM or client database for active clients by state
  const clients = await env.CLIENT_DB.prepare(`
    SELECT
      SUBSTR(mailing_address, -2) as state_code,
      COUNT(*) as client_count
    FROM clients
    WHERE status = 'active'
    GROUP BY SUBSTR(mailing_address, -2)
  `).all();

  const stateCounts = {};

  for (const row of clients.results) {
    if (row.state_code && row.state_code.length === 2) {
      stateCounts[row.state_code.toUpperCase()] = row.client_count;
    }
  }

  return stateCounts;
}

async function getFilingStatus(stateCode, env) {
  // Check if filing is in progress or completed
  const filing = await env.KV_STORAGE.get(`state_filing_${stateCode}`);

  if (filing) {
    const status = JSON.parse(filing);
    return {
      status: status.status, // 'not_started', 'in_progress', 'submitted', 'approved'
      filedDate: status.filedDate,
      expectedApproval: status.expectedApproval,
      notes: status.notes
    };
  }

  return {
    status: 'not_started',
    filedDate: null,
    expectedApproval: null,
    notes: 'No filing initiated'
  };
}

1.5 Automated Alert Generation

1.5.1 Daily Monitoring Cron Job

// Cloudflare Worker Cron trigger
async function scheduledStateComplianceCheck(env) {
  const alerts = await checkStateRegistrationLimits(env);

  if (alerts.length > 0) {
    // Send notifications for each alert
    for (const alert of alerts) {
      await sendComplianceAlert(alert, env);

      // Create or update filing task
      await createFilingTask(alert, env);
    }

    // Update compliance dashboard
    await updateComplianceDashboard(alerts, env);
  }
}

async function sendComplianceAlert(alert, env) {
  const message = `
🚨 State Registration Alert: ${alert.stateName}

Current Clients: ${alert.currentCount}/${alert.limit}
Status: ${alert.urgency}
Action Required: ${alert.actionRequired}

${alert.urgency === 'CRITICAL'
  ? '⚠️ IMMEDIATE ACTION REQUIRED - Cannot onboard new clients until filing is complete'
  : `🔔 ${alert.clientsRemaining} clients remaining before filing required`}

Processing Time: ${alert.estimatedProcessingTime}
Filing Status: ${alert.filingStatus.status}
  `;

  // Send via email/Slack/etc.
  await sendNotification(message, 'compliance-alerts', env);
}

1.6 Filing Task Management

1.6.1 Task Creation and Tracking

async function createFilingTask(alert, env) {
  const taskId = `state_filing_${alert.state}_${Date.now()}`;

  const task = {
    id: taskId,
    state: alert.state,
    stateName: alert.stateName,
    priority: alert.urgency,
    status: 'pending',
    createdDate: new Date().toISOString(),
    dueDate: calculateFilingDueDate(alert),
    requirements: getStateFilingRequirements(alert.state),
    estimatedCost: getStateFees(alert.state),
    assignee: 'sloane@ethicic.com'
  };

  // Store in task management system
  await env.KV_STORAGE.put(`filing_task_${taskId}`, JSON.stringify(task));

  // Add to compliance dashboard
  await addToComplianceDashboard(task, env);

  return task;
}

function getStateFilingRequirements(stateCode) {
  const requirements = {
    'CA': [
      'Complete Form ADV-NR (Notice of Registration)',
      'Pay $200 filing fee',
      'Submit current Form ADV Part 1A',
      'Provide surety bond documentation',
      'Submit fingerprint cards if required'
    ],
    'NY': [
      'File Form ADV-NR with IARD',
      'Pay $300 initial registration fee',
      'Submit audited financial statements',
      'Provide surety bond or net capital certification'
    ],
    'TX': [
      'Complete Texas State Notice Filing',
      'Pay $100 filing fee',
      'Submit Form ADV Part 1A and 2A',
      'Provide evidence of federal registration'
    ]
    // Add more states as needed
  };

  return requirements[stateCode] || ['Contact state securities regulator for requirements'];
}

function getStateFees(stateCode) {
  const fees = {
    'CA': '$200',
    'NY': '$300',
    'TX': '$100',
    'FL': '$150',
    'PA': '$250',
    'IL': '$200'
  };

  return fees[stateCode] || 'Contact state for fee schedule';
}

1.7 Integration with Client Onboarding

1.7.1 Pre-Onboarding State Check

async function validateStateCapacity(clientState, env) {
  const currentCount = await getClientCountForState(clientState, env);
  const limit = getStateRegistrationLimit(clientState);

  if (currentCount >= limit) {
    const filingStatus = await getFilingStatus(clientState, env);

    if (filingStatus.status !== 'approved') {
      return {
        canOnboard: false,
        reason: 'state_registration_limit_reached',
        message: `Cannot onboard new ${getStateName(clientState)} clients until state registration filing is complete.`,
        expectedResolution: filingStatus.expectedApproval || 'Filing not yet initiated',
        currentCount: currentCount,
        limit: limit
      };
    }
  }

  return {
    canOnboard: true,
    currentCount: currentCount,
    limit: limit,
    remainingCapacity: limit - currentCount
  };
}

1.8 Compliance Status Tracking

1.8.1 Filing Status Updates

async function updateFilingStatus(stateCode, status, details, env) {
  const filing = {
    status: status, // 'in_progress', 'submitted', 'approved', 'rejected'
    lastUpdated: new Date().toISOString(),
    filedDate: details.filedDate || null,
    expectedApproval: details.expectedApproval || null,
    approvalDate: details.approvalDate || null,
    notes: details.notes || '',
    updatedBy: details.updatedBy || 'system'
  };

  await env.KV_STORAGE.put(`state_filing_${stateCode}`, JSON.stringify(filing));

  // Update any related tasks
  await updateRelatedTasks(stateCode, status, env);

  // Notify if approved (can now onboard clients)
  if (status === 'approved') {
    await sendApprovalNotification(stateCode, env);
  }
}

async function sendApprovalNotification(stateCode, env) {
  const message = `
✅ State Registration Approved: ${getStateName(stateCode)}

Status: Registration complete
Impact: Can now onboard new ${getStateName(stateCode)} clients
Capacity: ${getStateRegistrationLimit(stateCode)} clients

Any clients waiting for ${getStateName(stateCode)} registration can now proceed with account opening.
  `;

  await sendNotification(message, 'compliance-updates', env);
}

1.9 Environment Variables Required

# Client Database
CLIENT_DB=

# Storage for filing status
KV_STORAGE=

# Notification systems
SLACK_WEBHOOK_COMPLIANCE=
EMAIL_ALERT_ENDPOINT=

This system provides proactive monitoring and prevents the “traffic jam” situations where clients are waiting for state registration filings to be completed before their accounts can be opened.

Owner: ?meta:owner
Last reviewed: ?meta:last_reviewed
SLA: ?meta:sla
Controls: ?meta:ops_controls
Commit: 8f0c18729ae96125ef5caf6824600a75c4928c16