@steve02081504/fount-p2p 0.0.30 → 0.0.32

package/sim/cli.mjs

@@ -0,0 +1,282 @@
+#!/usr/bin/env -S deno run --allow-scripts=npm:node-datachannel --allow-all
+/* global Deno */
+/**
+ * P2P 参数模拟器 + 挖矿器 CLI。
+ *
+ * 用法（勿用 blanket --allow-scripts：optional BLE 原生编译失败会整命令 abort，见 docs/runtime.md）:
+ *   deno run --allow-scripts=npm:node-datachannel --allow-all sim/cli.mjs sim --scenario balanced
+ *   deno run --allow-scripts=npm:node-datachannel --allow-all sim/cli.mjs mine --generations 20
+ *   deno run --allow-scripts=npm:node-datachannel --allow-all sim/cli.mjs mine --duration 5m
+ *   deno run --allow-scripts=npm:node-datachannel --allow-all sim/cli.mjs mine --duration 5m --no-apply
+ *   deno run --allow-scripts=npm:node-datachannel --allow-all sim/cli.mjs mine --social-tunables ../shells/social/src/federation/reputation_social.tunables.json
+ */
+import { applyTunablesBundle } from './apply.mjs'
+import { normalizeAttackGenome } from './attack_space.mjs'
+import { runCoevolution } from './coevolution.mjs'
+import { parseDurationMs } from './duration.mjs'
+import { DEFAULT_WEIGHTS, evaluateTunablesAgainstAttacks } from './metrics.mjs'
+import { runSimulation } from './model.mjs'
+import { shouldApplyResult } from './optimizer.mjs'
+import { writeReport } from './report.mjs'
+import { resolveScenarios } from './scenarios.mjs'
+import { defaultConcurrency, shutdownSimPool } from './sim_pool.mjs'
+import { loadDefaultTunables } from './tunables_bundle.mjs'
+import { analyzeVulnerabilities, formatVulnerabilityConsole } from './vulnerability.mjs'
+
+/**
+ * @param {string[]} argv CLI 参数（不含 node/脚本路径）
+ * @returns {Record<string, string | boolean> & { _: string[] }} 解析结果（`_` 为位置参数）
+ */
+function parseArgs(argv) {
+	/** @type {Record<string, string | boolean> & { _: string[] }} */
+	const out = { _: [] }
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i]
+		if (arg.startsWith('--')) {
+			const key = arg.slice(2)
+			const next = argv[i + 1]
+			if (!next || next.startsWith('--')) out[key] = true
+			else {
+				out[key] = next
+				i++
+			}
+		}
+		else out._.push(arg)
+	}
+	return out
+}
+
+/**
+ * @param {string | boolean | undefined} raw 原始参数值
+ * @param {number} fallback 解析失败时的默认值
+ * @returns {number} 数值
+ */
+function num(raw, fallback) {
+	const n = Number(raw)
+	return Number.isFinite(n) ? n : fallback
+}
+
+/**
+ * @param {string | boolean | undefined} raw 原始参数值
+ * @returns {number[]} 种子列表
+ */
+function parseSeeds(raw) {
+	if (typeof raw !== 'string') return [1, 2, 3, 4, 5, 6]
+	return raw.split(',').map(s => Number(s.trim())).filter(Number.isFinite)
+}
+
+/**
+ * @param {string | boolean | undefined} raw 原始 --jobs 参数
+ * @returns {number} 并发度
+ */
+function parseJobsLimit(raw) {
+	const n = Number(raw)
+	return Number.isFinite(n) && n >= 1 ? Math.floor(n) : defaultConcurrency()
+}
+
+/**
+ * @param {Record<string, string | boolean> & { _: string[] }} cliArguments 已解析 CLI 参数
+ * @returns {import('./metrics.mjs').EvalOptions} 评估并行选项（默认自动占满 CPU）
+ */
+function buildEvalOptions(cliArguments) {
+	if (cliArguments.serial || cliArguments.jobs === '1' || cliArguments.jobs === 1)
+		return { serial: true }
+	if (cliArguments.jobs != null && cliArguments.jobs !== true)
+		return { concurrency: parseJobsLimit(String(cliArguments.jobs)) }
+	return {}
+}
+
+/**
+ * @param {number | null} durationMs 时长上限
+ * @param {number} generations 代数上限
+ * @returns {(info: import('./optimizer.mjs').OptimizerProgress) => void} 进度打印器
+ */
+function createProgressPrinter(durationMs, generations) {
+	const isTty = typeof Deno.stdout.isTerminal === 'function' && Deno.stdout.isTerminal()
+	let lastWrite = 0
+	const encoder = new TextEncoder()
+
+	return (info) => {
+		const now = Date.now()
+		if (now - lastWrite < 200 && info.generation > 0) return
+		lastWrite = now
+
+		const pct = info.percent.toFixed(1)
+		const elapsed = (info.elapsedMs / 1000).toFixed(1)
+		const limit = durationMs != null ? `${(durationMs / 1000).toFixed(1)}` : `${generations}`
+		const line = `coevo ${pct}% | gen ${info.generationsRun} | blue ${info.bestFitness.toFixed(4)} | mean ${info.meanFitness.toFixed(4)} | ${elapsed}s/${limit}${durationMs != null ? 's' : ' gen'}`
+
+		if (isTty)
+			Deno.stdout.writeSync(encoder.encode(`\r${line.padEnd(80)}`))
+		else if (info.generation === 0 || info.generationsRun % 10 === 0)
+			console.log(line)
+	}
+}
+
+/**
+ * @param {Record<string, string | boolean> & { _: string[] }} cliArguments 已解析参数
+ * @returns {Promise<void>}
+ */
+async function cmdSim(cliArguments) {
+	const scenarioId = String(cliArguments.scenario || cliArguments.scenarios || 'balanced')
+	const seeds = parseSeeds(cliArguments.seeds)
+	const tunables = loadDefaultTunables()
+	const scenarios = resolveScenarios(scenarioId)
+
+	for (const scenario of scenarios)
+		for (const seed of seeds) {
+			const snap = runSimulation(scenario, seed, tunables)
+			console.log(JSON.stringify({ scenario: scenario.id, seed, snap }, null, 2))
+		}
+}
+
+/**
+ * @param {Record<string, string | boolean> & { _: string[] }} cliArguments 已解析参数
+ * @returns {Promise<void>}
+ */
+async function cmdMine(cliArguments) {
+	const scenarioId = String(cliArguments.scenarios || cliArguments.scenario || 'all')
+	const generations = num(cliArguments.generations, 20)
+	const population = num(cliArguments.population, 12)
+	const seeds = parseSeeds(cliArguments.seeds)
+	const seedBase = num(cliArguments.seedBase, 42)
+	const durationMs = parseDurationMs(cliArguments.duration)
+	const doApply = !(cliArguments['no-apply'] || cliArguments['dry-run'])
+	const skipFullEval = Boolean(cliArguments['skip-full-eval'])
+	const scenarios = resolveScenarios(scenarioId)
+	const evalOptions = buildEvalOptions(cliArguments)
+	const jobCount = evalOptions.serial ? 1 : evalOptions.concurrency ?? defaultConcurrency()
+
+	if (durationMs == null && cliArguments.duration != null && cliArguments.duration !== true)
+		console.warn(`warning: invalid --duration ${JSON.stringify(cliArguments.duration)}, using --generations instead`)
+
+	console.log(`parallel: ${evalOptions.serial ? 'off (serial)' : `${jobCount} workers (auto CPU)`}`)
+
+	const onProgress = createProgressPrinter(durationMs, generations)
+
+	const result = await runCoevolution({
+		scenarios,
+		generations,
+		population,
+		seeds,
+		seedBase,
+		weights: DEFAULT_WEIGHTS,
+		durationMs,
+		evalOptions,
+		onProgress,
+	})
+
+	if (typeof Deno.stdout.isTerminal === 'function' && Deno.stdout.isTerminal())
+		console.log('')
+
+	const { baseline, best, bestRed, attackHof, history, stoppedBy, generationsRun, elapsedMs } = result
+
+	const attackPanel = [
+		...attackHof.map(h => h.genome),
+		bestRed.attackGenome,
+		normalizeAttackGenome(undefined),
+	]
+
+	let baselineFull = best.result
+	let bestFull = best.result
+	let vulnerability = analyzeVulnerabilities(scenarios, bestFull)
+	/** @type {{ ok: boolean, reason: string }} */
+	let gate = { ok: false, reason: 'skip-full-eval' }
+
+	if (!skipFullEval) {
+		// 写回前一律在**全场景**上复评（含红队名人堂面板），避免单场景过拟合后污染全局默认值。
+		const allScenarios = resolveScenarios('all')
+		baselineFull = await evaluateTunablesAgainstAttacks(
+			allScenarios, seeds, baseline.tunables, attackPanel, runSimulation, DEFAULT_WEIGHTS, evalOptions,
+		)
+		bestFull = await evaluateTunablesAgainstAttacks(
+			allScenarios, seeds, best.tunables, attackPanel, runSimulation, DEFAULT_WEIGHTS, evalOptions,
+		)
+		vulnerability = analyzeVulnerabilities(allScenarios, bestFull)
+		gate = shouldApplyResult(baselineFull, bestFull)
+	}
+
+	/** @type {object} */
+	const applyInfo = {
+		applied: false,
+		reason: skipFullEval ? 'skip-full-eval' : doApply ? gate.reason : 'dry-run',
+		full: { baseline: baselineFull.fitness, best: bestFull.fitness },
+	}
+	if (doApply && gate.ok) {
+		const socialTunablesPath = cliArguments['social-tunables']
+		if (typeof socialTunablesPath !== 'string' || !socialTunablesPath.trim())
+			throw new Error('mine apply requires --social-tunables PATH (shell reputation_social.tunables.json)')
+		const written = await applyTunablesBundle(best.tunables, { socialTunablesPath })
+		applyInfo.applied = true
+		applyInfo.written = written
+	}
+
+	const payload = {
+		generatedAt: new Date().toISOString(),
+		scenarios: scenarios.map(s => s.id),
+		seeds,
+		generations: durationMs != null ? null : generations,
+		population,
+		durationMs,
+		elapsedMs,
+		stoppedBy,
+		generationsRun,
+		baseline: { result: baseline.result, tunables: baseline.tunables },
+		best: { result: best.result, tunables: best.tunables },
+		bestRed: { result: bestRed.result, attackGenome: bestRed.attackGenome },
+		attackHof,
+		history,
+		apply: applyInfo,
+		vulnerability,
+	}
+
+	const { jsonPath, mdPath } = await writeReport(payload, applyInfo.applied ? 'mine-applied' : 'mine')
+	console.log(`fitness baseline=${baseline.result.fitness.toFixed(4)} best=${best.result.fitness.toFixed(4)}`)
+	console.log(`red harm best=${(-bestRed.result.fitness).toFixed(4)} hof=${attackHof.length}`)
+	console.log(`all-scenario fitness baseline=${baselineFull.fitness.toFixed(4)} best=${bestFull.fitness.toFixed(4)}`)
+	if (durationMs != null)
+		console.log(`stopped by ${stoppedBy} after ${generationsRun} generation(s), elapsed ${(elapsedMs / 1000).toFixed(1)}s / ${(durationMs / 1000).toFixed(1)}s`)
+	console.log(`report: ${jsonPath}`)
+	console.log(`report: ${mdPath}`)
+	if (applyInfo.applied) console.log('applied best tunables to module JSON files')
+	else if (doApply) console.log(`not applied: ${applyInfo.reason}`)
+	else console.log('dry-run: tunables not written (use default apply; pass --no-apply to suppress)')
+
+	for (const line of formatVulnerabilityConsole(vulnerability))
+		console.log(line)
+}
+
+/**
+ * 打印 CLI 用法与选项说明。
+ */
+function printHelp() {
+	console.log(`usage:
+  cli.mjs sim [--scenario ID] [--seeds 1,2,3,4,5,6]
+  cli.mjs mine [--scenarios ID|all] [--generations N] [--duration 5m]
+               [--population N] [--seeds 1,2,3,4,5,6] [--jobs N] [--serial]
+               [--no-apply|--dry-run] [--skip-full-eval]
+               [--social-tunables PATH]  (required when applying social tunables)
+
+默认 mine 自动按 CPU 逻辑核心数并行仿真（无需额外参数）。
+--jobs N 可手动限制并发；--serial 或 --jobs 1 强制串行。
+默认 mine 会将最优参数写回各模块 JSON（需超过基线 + margin）。
+加 --no-apply 或 --dry-run 仅生成报告。
+快速迭代：--seeds 1 --population 8 --skip-full-eval`)
+}
+
+const cliArguments = parseArgs(Deno.args)
+const cmd = cliArguments._[0] || 'mine'
+
+try {
+	if (cliArguments.help || cliArguments.h) printHelp()
+	else if (cmd === 'sim') await cmdSim(cliArguments)
+	else if (cmd === 'mine') await cmdMine(cliArguments)
+	else {
+		console.error(`unknown command: ${cmd}`)
+		printHelp()
+		Deno.exit(1)
+	}
+}
+finally {
+	shutdownSimPool()
+}

package/sim/coevolution.mjs

@@ -0,0 +1,245 @@
+/**
+ * 竞争式共演进：蓝队(tunables) vs 红队(attack genome) + 名人堂。
+ */
+import {
+	mutateAttackGenome,
+	normalizeAttackGenome,
+	randomAttackGenome,
+	updateAttackHallOfFame,
+} from './attack_space.mjs'
+import { pastDeadline } from './duration.mjs'
+import { evaluateManyAgainstAttacks, evaluateTunablesAgainstAttacks, minPanelFitness } from './metrics.mjs'
+import { runSimulation } from './model.mjs'
+import { computeProgressPercent } from './optimizer.mjs'
+import { createRng } from './rng.mjs'
+import { mutateCandidate, randomCandidate } from './space.mjs'
+import { loadDefaultTunables } from './tunables_bundle.mjs'
+
+/**
+ * @typedef {{
+ *   tunables: import('./tunables_bundle.mjs').TunablesBundle,
+ *   attackGenome: import('./attack_space.mjs').AttackGenome,
+ *   result: Awaited<ReturnType<typeof evaluateTunablesAgainstAttacks>>,
+ *   generation: number,
+ * }} CoevoCandidate
+ */
+
+/**
+ * @param {import('./tunables_bundle.mjs').TunablesBundle} tunables 蓝队参数
+ * @param {import('./attack_space.mjs').AttackGenome[]} attackGenomes 红队基因组
+ * @returns {import('./metrics.mjs').EvalCandidate[]} 单基因组候选
+ */
+function redEvalCandidates(tunables, attackGenomes) {
+	return attackGenomes.map(attackGenome => ({
+		tunables,
+		attackPanel: [attackGenome],
+	}))
+}
+
+/**
+ * @param {Awaited<ReturnType<typeof evaluateManyAgainstAttacks>>} results 蓝队评估
+ * @returns {Awaited<ReturnType<typeof evaluateTunablesAgainstAttacks>>[]} 红队伤害评估
+ */
+function toRedHarmResults(results) {
+	return results.map(r => ({ ...r, fitness: 1 - r.fitness }))
+}
+
+/**
+ * @param {object} options 选项
+ * @param {import('./scenarios.mjs').SimScenario[]} options.scenarios 场景
+ * @param {number} [options.generations=20] 代数
+ * @param {number} [options.population=12] 蓝队种群
+ * @param {number} [options.redPopulation=8] 红队种群
+ * @param {number[]} [options.seeds] 种子
+ * @param {number} [options.seedBase=42] 搜索种子基
+ * @param {import('./metrics.mjs').MetricWeights} [options.weights] 权重
+ * @param {number | null} [options.durationMs] 时长上限
+ * @param {import('./metrics.mjs').EvalOptions} [options.evalOptions] 评估并行选项
+ * @param {(info: import('./optimizer.mjs').OptimizerProgress) => void} [options.onProgress] 进度
+ * @returns {Promise<object>} 共演进结果
+ */
+export async function runCoevolution(options) {
+	const {
+		scenarios,
+		generations = 20,
+		population = 12,
+		redPopulation = 8,
+		seeds = [1, 2, 3],
+		seedBase = 42,
+		weights,
+		durationMs = null,
+		evalOptions,
+		onProgress,
+	} = options
+
+	const startedAt = Date.now()
+	const deadline = durationMs != null && durationMs > 0 ? startedAt + durationMs : null
+	const timed = deadline != null
+
+	const baselineTunables = loadDefaultTunables()
+	const baselineAttack = normalizeAttackGenome(undefined)
+	const baselineEval = await evaluateTunablesAgainstAttacks(
+		scenarios, seeds, baselineTunables, [baselineAttack], runSimulation, weights, evalOptions,
+	)
+	const baseline = { tunables: baselineTunables, attackGenome: baselineAttack, result: baselineEval, generation: 0 }
+
+	let bestBlue = { ...baseline }
+	let bestRed = {
+		tunables: baselineTunables,
+		attackGenome: randomAttackGenome(() => Math.random()),
+		result: baselineEval,
+		generation: 0,
+	}
+
+	/** @type {Array<{ genome: import('./attack_space.mjs').AttackGenome, fitness: number }>} */
+	let attackHof = []
+	/** @type {CoevoCandidate[]} */
+	let bluePool = [{ ...baseline }]
+
+	const initBluePanel = [baselineAttack, ...attackHof.map(h => h.genome)]
+	const initBlueCandidates = []
+	for (let i = 1; i < population; i++)
+		initBlueCandidates.push({ tunables: randomCandidate(seedBase + i), attackPanel: initBluePanel })
+
+	if (initBlueCandidates.length) {
+		const initBlueResults = await evaluateManyAgainstAttacks(
+			scenarios, seeds, initBlueCandidates, runSimulation, weights, evalOptions,
+		)
+		for (let i = 0; i < initBlueResults.length; i++) {
+			const rec = {
+				tunables: initBlueCandidates[i].tunables,
+				attackGenome: baselineAttack,
+				result: initBlueResults[i],
+				generation: 0,
+			}
+			bluePool.push(rec)
+			if (initBlueResults[i].fitness > bestBlue.result.fitness) bestBlue = rec
+		}
+	}
+
+	/** @type {CoevoCandidate[]} */
+	let redPool = []
+	const initRedGenomes = []
+	for (let i = 0; i < redPopulation; i++)
+		initRedGenomes.push(randomAttackGenome(createRng(seedBase + 500 + i)))
+
+	const initRedResults = toRedHarmResults(await evaluateManyAgainstAttacks(
+		scenarios, seeds, redEvalCandidates(bestBlue.tunables, initRedGenomes), runSimulation, weights, evalOptions,
+	))
+	for (let i = 0; i < initRedResults.length; i++) {
+		const attackGenome = initRedGenomes[i]
+		const rec = { tunables: bestBlue.tunables, attackGenome, result: initRedResults[i], generation: 0 }
+		redPool.push(rec)
+		attackHof = updateAttackHallOfFame(attackHof, attackGenome, -initRedResults[i].fitness)
+		if (-initRedResults[i].fitness > -bestRed.result.fitness) bestRed = rec
+	}
+
+	/** @type {Array<{ generation: number, bestFitness: number, meanFitness: number, bestRedHarm: number }>} */
+	const history = [{
+		generation: 0,
+		bestFitness: bestBlue.result.fitness,
+		meanFitness: bluePool.reduce((s, c) => s + c.result.fitness, 0) / bluePool.length,
+		bestRedHarm: -bestRed.result.fitness,
+	}]
+
+	let gen = 1
+	let generationsRun = 0
+	while (true) {
+		if (!timed && gen > generations) break
+		if (timed && pastDeadline(deadline)) break
+
+		const attackPanel = [...attackHof.map(h => h.genome), ...redPool.slice(0, 3).map(r => r.attackGenome)]
+
+		bluePool.sort((a, b) => b.result.fitness - a.result.fitness)
+		const blueElites = bluePool.slice(0, Math.max(2, Math.floor(population / 4)))
+		/** @type {CoevoCandidate[]} */
+		const nextBlue = [...blueElites]
+		/** @type {Array<{ parent: CoevoCandidate, tunables: import('./tunables_bundle.mjs').TunablesBundle }>} */
+		const blueMutations = []
+		const blueOffspring = population - nextBlue.length
+		while (blueMutations.length < blueOffspring) {
+			const parent = blueElites[blueMutations.length % blueElites.length]
+			blueMutations.push({
+				parent,
+				tunables: mutateCandidate(parent.tunables, seedBase + gen * 1000 + nextBlue.length + blueMutations.length),
+			})
+		}
+		if (blueMutations.length) {
+			const blueBatch = blueMutations.map(m => ({ tunables: m.tunables, attackPanel }))
+			const blueResults = await evaluateManyAgainstAttacks(
+				scenarios, seeds, blueBatch, runSimulation, weights, evalOptions,
+			)
+			for (let i = 0; i < blueResults.length; i++) {
+				const rec = {
+					tunables: blueMutations[i].tunables,
+					attackGenome: blueMutations[i].parent.attackGenome,
+					result: blueResults[i],
+					generation: gen,
+				}
+				nextBlue.push(rec)
+				if (blueResults[i].fitness > bestBlue.result.fitness) bestBlue = rec
+			}
+		}
+		bluePool = nextBlue
+
+		redPool.sort((a, b) => a.result.fitness - b.result.fitness)
+		const redElites = redPool.slice(0, Math.max(2, Math.floor(redPopulation / 3)))
+		/** @type {CoevoCandidate[]} */
+		const nextRed = [...redElites]
+		/** @type {import('./attack_space.mjs').AttackGenome[]} */
+		const redMutations = []
+		const redOffspring = redPopulation - nextRed.length
+		while (redMutations.length < redOffspring) {
+			const parent = redElites[redMutations.length % redElites.length]
+			redMutations.push(mutateAttackGenome(parent.attackGenome, seedBase + gen * 2000 + nextRed.length + redMutations.length))
+		}
+		if (redMutations.length) {
+			const redResults = toRedHarmResults(await evaluateManyAgainstAttacks(
+				scenarios, seeds, redEvalCandidates(bestBlue.tunables, redMutations), runSimulation, weights, evalOptions,
+			))
+			for (let i = 0; i < redResults.length; i++) {
+				const attackGenome = redMutations[i]
+				const rec = { tunables: bestBlue.tunables, attackGenome, result: redResults[i], generation: gen }
+				nextRed.push(rec)
+				attackHof = updateAttackHallOfFame(attackHof, attackGenome, -redResults[i].fitness)
+				if (-redResults[i].fitness > -bestRed.result.fitness) bestRed = rec
+			}
+		}
+		redPool = nextRed
+
+		generationsRun = gen
+		history.push({
+			generation: gen,
+			bestFitness: bestBlue.result.fitness,
+			meanFitness: bluePool.reduce((s, c) => s + c.result.fitness, 0) / bluePool.length,
+			bestRedHarm: -bestRed.result.fitness,
+		})
+		if (onProgress)
+			onProgress({
+				generation: gen,
+				generationsRun,
+				bestFitness: bestBlue.result.fitness,
+				meanFitness: history[history.length - 1].meanFitness,
+				elapsedMs: Date.now() - startedAt,
+				durationMs,
+				generations,
+				percent: computeProgressPercent(durationMs, generations, gen, Date.now() - startedAt, timed),
+			})
+
+		gen++
+	}
+
+	return {
+		baseline,
+		best: bestBlue,
+		bestRed,
+		attackHof,
+		history,
+		stoppedBy: timed && pastDeadline(deadline) ? 'duration' : 'generations',
+		generationsRun,
+		durationMs,
+		elapsedMs: Date.now() - startedAt,
+	}
+}
+
+void minPanelFitness

package/sim/cold_start.md

@@ -0,0 +1,13 @@
+# Sim cold-start (K = 0)
+
+Mesh policy: [docs/mesh.md](../docs/mesh.md). Day-to-day sim rules: [AGENTS.md](AGENTS.md).
+
+When the observer has no acquaintances (`trustedPeers=[]`), the sim must still join via discovery explore slots — not idle.
+
+| Knob | Behavior |
+| --- | --- |
+| `scenario.coldStartObserver: true` | Observer starts with `trustedPeers=[]` |
+| `initObserverDiscovery(..., coldBootstrap=true)` | Discovery starts empty |
+| Each round: `coldStartDiscoveryJoin` | Simulates mesh scan / join |
+
+Scenario + regression: `cold_start` in `scenarios.mjs`, `sim/test/cold_start.test.mjs`.

package/sim/constants.mjs

@@ -0,0 +1,44 @@
+/**
+ * 仿真用拓扑/可达魔法常数（定性趋势，非真实网络推导）。
+ */
+export const MAILBOX_REACH_LOW_HOP_FACTOR = 0.45
+/**
+ * maxHop=2 时 mailbox 可达折损系数。
+ */
+export const MAILBOX_REACH_MID_HOP_FACTOR = 0.72
+/**
+ * 跳数成本指数（hopFactor 幂次）。
+ */
+export const MAILBOX_HOP_COST_EXPONENT = 1.5
+/**
+ * 跳数成本线性缩放系数。
+ */
+export const MAILBOX_HOP_COST_SCALE = 0.28
+/**
+ * wantFanout 超基准（3）的附加成本系数。
+ */
+export const MAILBOX_FANOUT_COST_SCALE = 0.05
+/**
+ * 超过必要跳数时的惩罚系数。
+ */
+export const MAILBOX_EXCESS_HOP_PENALTY = 0.24
+/**
+ * relay 步数归一化除数（分母项）。
+ */
+export const MAILBOX_RELAY_COST_DIVISOR = 6
+/**
+ * 联邦单 peer 覆盖概率上限。
+ */
+export const FEDERATION_SINGLE_PEER_CAP = 0.55
+/**
+ * 联邦单 peer 覆盖概率缩放（÷ 在线诚实 relay 数）。
+ */
+export const FEDERATION_SINGLE_PEER_SCALE = 1.4
+/**
+ * 攻击方发现门控基线概率（仿真代理）。
+ */
+export const ATTACK_DISCOVERY_GATE_BASE = 0.55
+/**
+ * Sybil 声誉收益冷却轮数（此前轮次不发放）。
+ */
+export const SYBIL_REP_EARN_COST_ROUNDS = 4