minor [Performance & Scalability]
→ ]8;;vscode://file//work/apps/alp-fusion/src/client/fuseLoop.ts:74apps/alp-fusion/src/client/fuseLoop.ts:74-78]8;;

Reject invalid delay overrides.

A negative delay skips sleep at Line 93. A non-finite delay also does
not provide a reliable pause. A configuration error can create an
unthrottled rejoin loop and high CPU use.

Validate that each override is finite and non-negative. Keep 0 valid if
immediate rejoin is intentional. Add tests for negative and non-finite
values.






Proposed delay validation

 export async function runFuseLoop(opts: RunFuseLoopOptions): Promise<void> {
     const sleep = opts.sleep ?? defaultSleep;
+    const resolveDelay = (value: number | undefined, fallback: number): number => {
+        const delayMs = value ?? fallback;
+        if (!Number.isFinite(delayMs) || delayMs < 0) {
+            throw new RangeError('Fuse loop delays must be finite and non-negative');
+        }
+        return delayMs;
+    };
     const delays = {
-        successDelayMs: opts.successDelayMs ?? FUSE_LOOP.successDelayMs,
-        failureDelayMs: opts.failureDelayMs ?? FUSE_LOOP.failureDelayMs,
-        idleDelayMs: opts.idleDelayMs ?? FUSE_LOOP.idleDelayMs,
+        successDelayMs: resolveDelay(opts.successDelayMs, FUSE_LOOP.successDelayMs),
+        failureDelayMs: resolveDelay(opts.failureDelayMs, FUSE_LOOP.failureDelayMs),
+        idleDelayMs: resolveDelay(opts.idleDelayMs, FUSE_LOOP.idleDelayMs),
     };

major [Stability & Availability]
→ ]8;;vscode://file//work/apps/alp-fusion/src/client/continuous.ts:48apps/alp-fusion/src/client/continuous.ts:48-64]8;;

Prevent overlapping run() calls.

If code calls run() again before the first call completes, Line 50
replaces the first controller. stop() then aborts only the newest loop.
The first loop can remain asleep for its full delay. Its finally block
can also clear the newer controller.

Reject a second call while a loop is active, or track each active
controller. Clear stopAbort only when it still belongs to this
invocation. Add a regression test that starts two loops and calls
stop().






Proposed lifecycle guard

 async run(runOnce: () => Promise<FuseLoopOutcome>): Promise<void> {
+    if (this.stopAbort !== null) {
+        throw new Error('ContinuousClient is already running');
+    }
     this.stopped = false;
-    this.stopAbort = new AbortController();
+    const stopAbort = new AbortController();
+    this.stopAbort = stopAbort;
     try {
         await runFuseLoop({
             shouldStop: () => this.stopped,
-            abortSignal: this.stopAbort.signal,
+            abortSignal: stopAbort.signal,
             runOnce,
             sleep: this.opts.sleep,
             successDelayMs: this.opts.successDelayMs,
             failureDelayMs: this.opts.failureDelayMs,
             idleDelayMs: this.opts.idleDelayMs,
             onIteration: this.opts.onIteration,
         });
     } finally {
-        this.stopAbort = null;
+        if (this.stopAbort === stopAbort) {
+            this.stopAbort = null;
+        }
     }
 }

major [Security & Privacy]
→ ]8;;vscode://file//work/apps/alp-fusion/DEPLOY.md:64apps/alp-fusion/DEPLOY.md:64-68]8;;

Require TLS for public coordinators.

Line 66 makes TLS optional on public hosts. This conflicts with the
public-coordinator target in README.md. Require TLS for every public
listener. Limit plaintext TCP to isolated local correctness labs.






Proposed fix

-1. **One coordinator** bound on `0.0.0.0:8788` (optional TLS for public hosts).
+1. **One coordinator** bound with mandatory TLS on public networks. Use
+   plaintext TCP only in isolated local correctness labs.

major [Stability & Availability]
→ ]8;;vscode://file//work/apps/alp-fusion/src/client/fuseLoop.ts:55apps/alp-fusion/src/client/fuseLoop.ts:55-59]8;;

Validate delay overrides before the loop starts.

Negative values and NaN bypass the sleep at line 85. If runOnce fails
immediately, the loop then retries in a tight loop until stopped. Reject
non-finite and negative delay values. Keep 0 as an explicit no-delay
value.






Proposed validation

+function validateDelay(delayMs: number, name: string): number {
+    if (!Number.isFinite(delayMs) || delayMs < 0) {
+        throw new RangeError(`${name} must be a finite non-negative number`);
+    }
+    return delayMs;
+}
+
 export async function runFuseLoop(opts: RunFuseLoopOptions): Promise<void> {
     const sleep = opts.sleep ?? defaultSleep;
     const delays = {
-        successDelayMs: opts.successDelayMs ?? FUSE_LOOP.successDelayMs,
-        failureDelayMs: opts.failureDelayMs ?? FUSE_LOOP.failureDelayMs,
-        idleDelayMs: opts.idleDelayMs ?? FUSE_LOOP.idleDelayMs,
+        successDelayMs: validateDelay(
+            opts.successDelayMs ?? FUSE_LOOP.successDelayMs,
+            'successDelayMs',
+        ),
+        failureDelayMs: validateDelay(
+            opts.failureDelayMs ?? FUSE_LOOP.failureDelayMs,
+            'failureDelayMs',
+        ),
+        idleDelayMs: validateDelay(
+            opts.idleDelayMs ?? FUSE_LOOP.idleDelayMs,
+            'idleDelayMs',
+        ),
     };

major [Security & Privacy]
→ ]8;;vscode://file//work/apps/alp-fusion/DEPLOY.md:65apps/alp-fusion/DEPLOY.md:65]8;;

Require TLS for public coordinator endpoints.

Line 65 makes TLS optional for public hosts. This conflicts with the
README requirement for public coordinators. Plain TCP has no transport
confidentiality or integrity. Require TLS for every Internet-reachable
coordinator. Restrict cleartext operation to isolated local correctness
labs.






Proposed documentation fix

-1. **One coordinator** bound on `0.0.0.0:8788` (optional TLS for public hosts).
+1. **One coordinator** bound on `0.0.0.0:8788` with TLS for public hosts.
+   Restrict cleartext operation to isolated local correctness labs.