2.2.P. Concurrency Exposure

Metric: Temporal Static and Signal-to-Noise Ratio

Summary: Visualizes "Temporal Static" and the Signal-to-Noise Ratio of a file. Concurrency is treated as "Information Static" because it fractures the linear execution timeline, increasing the cognitive load required to understand the file. The "Tiger in the Cage" rule applies here: We do not discount concurrency just because it lives in a "Worker" or "API" folder. A tiger in a cage is still dangerous. High concurrency is always high cognitive load and high risk, regardless of where it lives.

Effect: Maps directly to the GitGalaxy Universal Risk Spectrum. * 🟦 LOW (Score 0-19): Linear. The code executes sequentially (1, then 2, then 3). The signal is clear and stable. * 🟨 MODERATE (Score 40-59): Standard async operations. Minor temporal branching. * 🟥 VERY HIGH (Score 80-100): Noisy. The code manages multiple parallel timelines (Promises, threads, channels). The signal is highly fractured, warning that execution timing is non-deterministic.

2.2.P.1. The Inputs (Temporal Markers)

We count the keywords that "Fork" time.

Variable	Regex Key	Weight	Structural Definition
`AsyncHits`	`concurrency`	1.0x	The Fork. Keywords that spawn or manage parallel execution: `async`, `await`, `Promise`, `thread`, `spawn`, `go`, `chan`, `synchronized`.
`LOC`	`meaningful_loc`	Denominator	We measure density. A 1,000-line file with 1 `await` is linear. A 10-line file with 5 `await`s is a temporal knot.

2.2.P.2. The Universal Framework Integration

$\text{Fc}$ (Fidelity Coefficient): Not Applied. Time is absolute.
$\text{Irc}$ (Implicit Risk Correction): Applied to Numerator (Dampened). Implicit languages (JS, Python) hide race conditions better than explicit ones (Rust, Go). We add a small "Ghost Load" to density, but we scale it down ($\text{Irc} \times 0.1$) so it acts as a "Tie Breaker" rather than a false positive generator.
$\text{Mp}$ (Path Modifier): Applied to Threshold.
UI/Views ($\text{Mp} = 0.5$): Low Tolerance (High Scream). Async logic in UI code is a primary source of bugs (race conditions, jank). We lower the bar so even minor concurrency glows here.
Standard/Workers ($\text{Mp} = 1.0$): Standard Tolerance. We do NOT discount workers. If a worker is complex, it should look complex.

2.2.P.3. The Equation: The Tipping Point Sigmoid

Concurrency complexity is non-linear. A single await is standard. Ten await calls in a small function is a "Logic Tangle." We use a Sigmoid to create a visual "Tipping Point."

Step A: Pre-Filter (The Zero Check) If the file contains Zero async hits, the score is $0.0$. No amount of implicit risk can turn synchronous code into concurrent code.

Step B: Calculate Temporal Density We determine what percentage of the code is dedicated to managing time. We add a fraction of $\text{Irc}$ ($0.1\times$) to penalize implicit safety gaps without creating noise.

\[\text{WeightedHits} = \text{AsyncHits} + (\text{Irc} \times 0.1)$$ $$\text{Density} = \left( \frac{\text{WeightedHits}}{\max(\text{LOC}, 1)} \right) \times 100.0\]

Step C: Determine The Threshold (The Breakdown) This is the density required to "Fracture" the signal. We start with a Base of $4.0$ (4% density), which provides a safe buffer for standard async patterns before triggering warnings.

\[\text{Threshold} = 4.0 \times \text{Mp}\]

Step D: The Sigmoid Map We map density against the threshold using a moderately steep slope ($0.4$). Concurrency risk escalates quickly once it crosses the threshold.

\[\text{RawScore} = \frac{100.0}{1 + e^{-0.4 \times (\text{Density} - \text{Threshold})}}$$ $$\text{FinalScore} = \min(\text{RawScore}, 100.0)\]

2.2.P.4. Implementation (Python Reference)

```python import math

def calculate_concurrency_exposure(self, hits_async, loc, irc, mp): """ Calculates 2.2.P Concurrency Exposure (Temporal Static). Returns int 0-100. """ # 1. Step A: Pre-Filter (Zero Check) if hits_async == 0: return 0

# 2. Step B: Temporal Density
# Scaled Irc (0.1x) prevents false positives in small files
weighted_hits = hits_async + (irc * 0.1)
density = (weighted_hits / max(loc, 1)) * 100

# 3. Step C: Dynamic Threshold
# Base = 4% density.
# UI (Mp 0.5) -> Threshold 2.0%.
# Workers/Standard (Mp 1.0) -> Threshold 4.0%.
path_mod = mp.get('Concurrency Exposure', 1.0)
threshold = 4.0 * path_mod

# 4. Step D: Sigmoid Map
try:
    raw_score = 100 / (1 + math.exp(-0.4 * (density - threshold)))
except OverflowError:
    raw_score = 100 if density > threshold else 0

return int(min(raw_score, 100))