Strengthen CLI benchmark verification

src/apps/cli/testdeno/bench-latency-sweep.ts

@@ -2,6 +2,8 @@ type SweepResult = {
     name: string;
     runner: "p2p" | "couchdb";
     rttMs?: number;
+    repeatIndex: number;
+    repeatCount: number;
     result: Record<string, unknown>;
 };
 
@@ -19,6 +21,15 @@ function timestamp(): string {
     );
 }
 
+function readEnvInteger(name: string, fallback: number): number {
+    const raw = readEnvString(name, String(fallback));
+    const parsed = Number(raw);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new Error(`${name} must be a positive integer, got '${raw}'`);
+    }
+    return parsed;
+}
+
 function parseRttList(raw: string): number[] {
     const values = raw
         .split(",")
@@ -41,6 +52,7 @@ function buildBaseEnv(): Record<string, string> {
         BENCH_SYNC_TIMEOUT: readEnvString("BENCH_SYNC_TIMEOUT", "300"),
         BENCH_PEERS_TIMEOUT: readEnvString("BENCH_PEERS_TIMEOUT", "60"),
         BENCH_SEED: readEnvString("BENCH_SEED", "livesync-benchmark-seed"),
+        BENCH_VERIFY_MODE: readEnvString("BENCH_VERIFY_MODE", "all"),
         LIVESYNC_TEST_TEE: readEnvString("BENCH_LIVESYNC_TEST_TEE", "0"),
     };
 }
@@ -50,12 +62,19 @@ async function runBenchmark(options: {
     name: string;
     outputDir: string;
     env: Record<string, string>;
+    repeatIndex: number;
+    repeatCount: number;
 }): Promise<Record<string, unknown>> {
-    const resultPath = `${options.outputDir}/${options.name}.json`;
+    const suffix = options.repeatCount > 1
+        ? `-r${String(options.repeatIndex).padStart(2, "0")}`
+        : "";
+    const resultPath = `${options.outputDir}/${options.name}${suffix}.json`;
     const env = {
         ...Deno.env.toObject(),
         ...options.env,
         BENCH_RESULT_JSON: resultPath,
+        BENCH_REPEAT_INDEX: String(options.repeatIndex),
+        BENCH_REPEAT_COUNT: String(options.repeatCount),
     };
 
     console.log(`[latency-sweep] running ${options.name}`);
@@ -78,46 +97,69 @@ async function main(): Promise<void> {
     const outRoot = readEnvString("BENCH_SWEEP_ROOT", `${import.meta.dirname}/bench-results`);
     const outputDir = `${outRoot}/latency-sweep-${timestamp()}`;
     const rtts = parseRttList(readEnvString("BENCH_SWEEP_RTT_MS", "20,50,100,150,300"));
+    const repeatCount = readEnvInteger("BENCH_REPEAT_COUNT", 1);
     const base = buildBaseEnv();
 
     await Deno.mkdir(outputDir, { recursive: true });
 
     const results: SweepResult[] = [];
     if (readEnvString("BENCH_SWEEP_INCLUDE_P2P", "true") !== "false") {
-        const p2pResult = await runBenchmark({
-            taskName: "bench:p2p",
-            name: "p2p-direct-local",
-            outputDir,
-            env: {
-                ...base,
-                BENCH_CASE: "p2p-direct-local",
-                BENCH_TURN_SERVERS: "",
-            },
-        });
-        results.push({ name: "p2p-direct-local", runner: "p2p", result: p2pResult });
+        for (let repeatIndex = 1; repeatIndex <= repeatCount; repeatIndex++) {
+            const p2pResult = await runBenchmark({
+                taskName: "bench:p2p",
+                name: "p2p-direct-local",
+                outputDir,
+                repeatIndex,
+                repeatCount,
+                env: {
+                    ...base,
+                    BENCH_CASE: "p2p-direct-local",
+                    BENCH_TURN_SERVERS: "",
+                },
+            });
+            results.push({
+                name: "p2p-direct-local",
+                runner: "p2p",
+                repeatIndex,
+                repeatCount,
+                result: p2pResult,
+            });
+        }
     }
 
     for (const rtt of rtts) {
         const name = `couchdb-rtt-${rtt}ms`;
-        const couchdbResult = await runBenchmark({
-            taskName: "bench:couchdb",
-            name,
-            outputDir,
-            env: {
-                ...base,
-                BENCH_CASE: name,
-                BENCH_COUCHDB_RTT_MS: String(rtt),
-            },
-        });
-        results.push({ name, runner: "couchdb", rttMs: rtt, result: couchdbResult });
+        for (let repeatIndex = 1; repeatIndex <= repeatCount; repeatIndex++) {
+            const couchdbResult = await runBenchmark({
+                taskName: "bench:couchdb",
+                name,
+                outputDir,
+                repeatIndex,
+                repeatCount,
+                env: {
+                    ...base,
+                    BENCH_CASE: name,
+                    BENCH_COUCHDB_RTT_MS: String(rtt),
+                },
+            });
+            results.push({
+                name,
+                runner: "couchdb",
+                rttMs: rtt,
+                repeatIndex,
+                repeatCount,
+                result: couchdbResult,
+            });
+        }
     }
 
     const summary = {
         generatedAt: new Date().toISOString(),
         outputDir,
         note:
-            "This sweep models additional remote CouchDB request latency through the existing HTTP proxy. It is not a full netem model of jitter, loss, MTU, bandwidth, or VPN encapsulation.",
+            "This sweep applies half of each requested CouchDB RTT before forwarding requests and half before returning responses. It is not a full netem model of jitter, loss, MTU, bandwidth, or VPN encapsulation.",
         rtts,
+        repeatCount,
         results,
     };
     await Deno.writeTextFile(`${outputDir}/summary.json`, JSON.stringify(summary, null, 2));