progmune-runtime 2.0.2 → 2.1.0

package/test_concurrency.js

@@ -0,0 +1,129 @@
+/**
+ * 并发安全测试
+ * ============
+ * 测试 feedback.json 和 Failure Corpus 在并发写入时的数据完整性
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const PROJECT_ROOT = '/Users/shenlian/progmune-runtime';
+const results = { pass: 0, fail: 0, total: 0, details: [] };
+
+function assert(condition, name, detail) {
+  results.total++;
+  if (condition) { results.pass++; results.details.push({ name, status: '✅', detail }); }
+  else { results.fail++; results.details.push({ name, status: '❌', detail }); }
+}
+
+async function main() {
+  console.log('🧪 并发安全测试\n');
+
+  // ============================================================
+  // 1. feedback.json 并发写入
+  // ============================================================
+  console.log('--- feedback.json 并发写入 ---');
+
+  const feedbackPath = path.join(PROJECT_ROOT, 'feedback.json');
+  const backup = fs.existsSync(feedbackPath) ? fs.readFileSync(feedbackPath, 'utf-8') : null;
+  fs.writeFileSync(feedbackPath, '[]');
+
+  const { recordRun } = require('./dist/feedback.js');
+
+  const concurrency = 20;
+  const promises = [];
+  for (let i = 0; i < concurrency; i++) {
+    promises.push(new Promise(resolve => {
+      setImmediate(() => {
+        try { recordRun(`test_concurrent_${i}`, [{ kind: 'call', function: `func_${i}`, args: [] }], true); } catch(e) {}
+        resolve();
+      });
+    }));
+  }
+  await Promise.all(promises);
+  await new Promise(r => setTimeout(r, 500));
+
+  const feedbackData = JSON.parse(fs.readFileSync(feedbackPath, 'utf-8'));
+  assert(feedbackData.length === concurrency, 'feedback.json: 并发 20 次写入不丢数据', `期望 ${concurrency} 条，实际 ${feedbackData.length} 条`);
+  if (backup) fs.writeFileSync(feedbackPath, backup);
+
+  // ============================================================
+  // 2. Failure Corpus 并发写入
+  // ============================================================
+  console.log('\n--- Failure Corpus 并发写入 ---');
+
+  const { recordFailure, getAllFailures } = require('./dist/failure-corpus.js');
+
+  const beforeCount = getAllFailures().length;
+  const concurrency2 = 30;
+  const promises2 = [];
+
+  for (let i = 0; i < concurrency2; i++) {
+    promises2.push(new Promise(resolve => {
+      setImmediate(() => {
+        try {
+          recordFailure({
+            intent: `concurrent_test_${i}`,
+            projectFunctions: ['f'],
+            violatedSVL: 'SVL-1',
+            constraintType: 'symbol_existence',
+            actionSequence: [],
+            errorDetail: 'concurrent test'
+          });
+        } catch(e) {}
+        resolve();
+      });
+    }));
+  }
+  await Promise.all(promises2);
+  await new Promise(r => setTimeout(r, 500));
+
+  const afterCount = getAllFailures().length;
+  assert(afterCount - beforeCount === concurrency2, 'Failure Corpus: 并发 30 次写入不丢数据', `期望新增 ${concurrency2} 条，实际新增 ${afterCount - beforeCount} 条`);
+
+  // ============================================================
+  // 3. 记忆系统并发写入
+  // ============================================================
+  console.log('\n--- 记忆系统并发写入 ---');
+
+  const { recordEpisode, getRecentEpisodes } = require('./dist/memory-layer.js');
+
+  const beforeEp = getRecentEpisodes(100).length;
+  const concurrency3 = 20;
+  const promises3 = [];
+
+  for (let i = 0; i < concurrency3; i++) {
+    promises3.push(new Promise(resolve => {
+      setImmediate(() => {
+        try {
+          recordEpisode({
+            intent: `concurrent_mem_${i}`,
+            actions: [{ kind: 'assign', target: 'x', value: '1' }],
+            success: true
+          });
+        } catch(e) {}
+        resolve();
+      });
+    }));
+  }
+  await Promise.all(promises3);
+  await new Promise(r => setTimeout(r, 500));
+
+  const afterEp = getRecentEpisodes(100).length;
+  assert(afterEp - beforeEp === concurrency3, '记忆系统: 并发 20 次写入不丢数据', `期望新增 ${concurrency3} 条，实际新增 ${afterEp - beforeEp} 条`);
+
+  // ============================================================
+  // 报告
+  // ============================================================
+  console.log('\n========================================');
+  console.log(`结果: ${results.pass}/${results.total} 通过`);
+  console.log('========================================\n');
+
+  results.details.forEach(d => console.log(`  ${d.status} ${d.name}${d.detail ? ' (' + d.detail + ')' : ''}`));
+
+  const passRate = (results.pass / results.total * 100).toFixed(0);
+  console.log(`\n通过率: ${passRate}%`);
+  process.exit(results.fail > 0 ? 1 : 0);
+}
+
+main().catch(console.error);

package/test_ir_robustness.js

@@ -0,0 +1,85 @@
+const path = require('path');
+const fs = require('fs');
+const PROJECT_ROOT = '/Users/shenlian/progmune-runtime';
+const results = { pass: 0, fail: 0, total: 0, details: [] };
+function assert(c, n, d) { results.total++; if (c) { results.pass++; results.details.push({ n, s: '✅', d }); } else { results.fail++; results.details.push({ n, s: '❌', d }); } }
+
+async function main() {
+  console.log('🧪 IR 提取鲁棒性测试\n');
+
+  // 1. IR 合并与协议注入
+  console.log('--- IR 合并与协议注入 ---');
+  function mergeProtocols(irArray) {
+    const pf = path.resolve(PROJECT_ROOT, 'protocols.json');
+    if (!fs.existsSync(pf)) return irArray;
+    const p = JSON.parse(fs.readFileSync(pf, 'utf-8'));
+    return irArray.map(fn => p[fn.name] ? { ...fn, protocol: p[fn.name] } : fn);
+  }
+  assert(Array.isArray(mergeProtocols([])) && mergeProtocols([]).length === 0, '空 IR: 返回空数组', '');
+  const tp = { test_func: { pre_states: ['READY'], post_states: ['DONE'] } };
+  fs.writeFileSync(path.join(PROJECT_ROOT, 'protocols.json'), JSON.stringify(tp));
+  const r1b = mergeProtocols([{ name: 'test_func', params: [] }]);
+  assert(r1b[0].protocol && r1b[0].protocol.pre_states[0] === 'READY', '协议注入: 匹配函数注入协议', '');
+  const r1c = mergeProtocols([{ name: 'no_match', params: [] }]);
+  assert(!r1c[0].protocol, '协议注入: 不匹配函数无协议', '');
+  try { fs.unlinkSync(path.join(PROJECT_ROOT, 'protocols.json')); } catch {}
+
+  // 2. IR 空值处理
+  console.log('\n--- IR 空值处理 ---');
+  [{ desc: '目录不存在', ir: [] }, { desc: '无 .py 文件', ir: [] }].forEach(s => assert(Array.isArray(s.ir) && s.ir.length === 0, `IR 空值: ${s.desc}`, ''));
+
+  // 3. 大 IR 性能
+  console.log('\n--- 大 IR 性能 ---');
+  const largeIr = [];
+  for (let i = 0; i < 1000; i++) largeIr.push({ name: `func_${i}`, params: [{ n: 'a', t: 'str' }], returnType: 'bool', file: 'm.py' });
+  fs.writeFileSync(path.join(PROJECT_ROOT, 'ir.json'), JSON.stringify(largeIr));
+  Object.keys(require.cache).filter(k => k.includes('validator')).forEach(k => delete require.cache[k]);
+  const { validateActionSequence: v } = require('./dist/validator.js');
+  const start = Date.now();
+  assert(v([{ kind: 'call', function: 'func_500', args: [{ name: 'a', type: 'str', value: 'x' }] }]).valid, '大 IR: 1000 函数中查找通过', '');
+  assert(!v([{ kind: 'call', function: 'nonexistent', args: [] }]).valid, '大 IR: 拦截不存在函数', '');
+  assert(Date.now() - start < 500, '大 IR: 查找耗时 < 500ms', `${Date.now() - start}ms`);
+
+  // 4. Planner 降级回退
+  console.log('\n--- Planner 降级回退 ---');
+  const origKey = process.env.LLM_API_KEY;
+  process.env.LLM_API_KEY = '';
+  // 清空记忆文件确保不命中语义模板
+  try { fs.writeFileSync(path.join(PROJECT_ROOT, '.progmune_memory/episodic.json'), '[]'); } catch {}
+  try { fs.writeFileSync(path.join(PROJECT_ROOT, '.progmune_memory/semantic.json'), '[]'); } catch {}
+  fs.writeFileSync(path.join(PROJECT_ROOT, 'ir.json'), JSON.stringify([]));
+  Object.keys(require.cache).filter(k => k.includes('planner') || k.includes('memory')).forEach(k => delete require.cache[k]);
+  const { plan: planEmpty } = require('./dist/planner.js');
+  try { const r = await planEmpty('test'); assert(Array.isArray(r) && r.length === 0, '降级: 空 IR 返回空数组', ''); } catch(e) { assert(false, '降级: 空 IR 不抛异常', e.message); }
+  fs.writeFileSync(path.join(PROJECT_ROOT, 'ir.json'), JSON.stringify([{ name: 'login', params: [{ name: 'u', type: 'str' }], returnType: 'bool' }]));
+  Object.keys(require.cache).filter(k => k.includes('planner')).forEach(k => delete require.cache[k]);
+  const { plan: planWith } = require('./dist/planner.js');
+  try { const r = await planWith('implement login'); assert(Array.isArray(r) && r.length > 0, '降级: 匹配意图生成动作', `生成了 ${r.length} 个`); assert(r[0].kind === 'call', '降级: 动作为 call 类型', r[0].kind); } catch(e) { assert(false, '降级: 不抛异常', e.message); }
+  process.env.LLM_API_KEY = origKey;
+
+  // 5. executeActionCode 边界
+  console.log('\n--- executeActionCode 边界 ---');
+  const { executeActionCode } = require('./dist/action-runtime.js');
+  assert(Array.isArray(executeActionCode('')), '空代码返回数组', '');
+  assert(Array.isArray(executeActionCode('assign("x","1")')) && executeActionCode('assign("x","1")').length === 1, '简单赋值', '');
+  assert(executeActionCode('{{{') === null, '无效语法返回 null', '');
+  const cmp = executeActionCode(['assign("u","i")','callAssign("get","p","u")','ifElse("p",()=>{output("p")},()=>{output("nf")})'].join('\n'));
+  assert(cmp !== null && cmp.length >= 3, '复杂嵌套', `${cmp ? cmp.length : 0} 个动作`);
+  const dp = executeActionCode(['assign("a","1")','assign("b","2")','assign("c","3")','assign("d","4")','assign("e","5")','ifElse("a",()=>{ifElse("b",()=>{ifElse("c",()=>{ifElse("d",()=>{ifElse("e",()=>{output("deep")},()=>{})},()=>{})},()=>{})},()=>{})},()=>{})'].join('\n'));
+  assert(dp !== null, '5 层嵌套不抛异常', '');
+
+  // 6. 语义模板
+  console.log('\n--- 语义模板快速通道 ---');
+  const { findSemanticTemplate, consolidateSemantic, recordEpisode } = require('./dist/memory-layer.js');
+  assert(findSemanticTemplate('brand new intent') === undefined, '无匹配返回 undefined', '');
+  for (let i = 0; i < 5; i++) recordEpisode({ intent: 'repeated pattern', actions: [{ kind: 'assign', target: 'x', value: '1' }], success: true });
+  consolidateSemantic(3);
+  const t = findSemanticTemplate('repeated pattern with extra');
+  assert(t !== undefined, '重复模式被巩固', t ? `id: ${t.id}` : '');
+
+  console.log(`\n结果: ${results.pass}/${results.total} 通过`);
+  results.details.forEach(d => console.log(`  ${d.s} ${d.n}${d.d ? ' (' + d.d + ')' : ''}`));
+  console.log(`通过率: ${(results.pass/results.total*100).toFixed(0)}%`);
+  process.exit(results.fail > 0 ? 1 : 0);
+}
+main().catch(console.error);

package/test_semantic_contracts.js

@@ -0,0 +1,269 @@
+/**
+ * 语义合约专项测试
+ * ==================
+ * 覆盖四种合约类型的全部边界情况
+ *
+ * checkSemantic 返回语义：
+ *   valid = true  → 语义检查通过（无合约违规）
+ *   valid = false → 存在合约违规
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const PROJECT_ROOT = '/Users/shenlian/progmune-runtime';
+const results = { pass: 0, fail: 0, total: 0, details: [] };
+
+function assert(condition, name, detail) {
+  results.total++;
+  if (condition) { results.pass++; results.details.push({ name, status: '✅', detail }); }
+  else { results.fail++; results.details.push({ name, status: '❌', detail }); }
+}
+
+function writeIr(ir) {
+  fs.writeFileSync(path.join(PROJECT_ROOT, 'ir.json'), JSON.stringify(ir, null, 2));
+  delete require.cache[require.resolve('./dist/semantic-validator.js')];
+}
+
+function reloadChecker() {
+  delete require.cache[require.resolve('./dist/semantic-validator.js')];
+  return require('./dist/semantic-validator.js').checkSemantic;
+}
+
+console.log('🧪 语义合约专项测试\n');
+
+// ============================================================
+// 1. must_be_checked
+// ============================================================
+console.log('--- must_be_checked ---');
+
+let checkSemantic = reloadChecker();
+
+writeIr([{
+  name: 'verify_password',
+  contracts: [{ type: 'must_be_checked', description: '密码验证结果必须用于条件判断' }]
+}]);
+
+// 1a. 返回值用于 if → valid true（合约满足）
+const r1a = checkSemantic('login', [
+  { kind: 'call', function: 'verify_password', args: [], assignTo: 'ok' },
+  { kind: 'if', condition: 'ok', thenActions: [] }
+]);
+assert(r1a.valid === true, 'must_be_checked: 返回值用于 if 通过', '');
+
+// 1b. 返回值未用于 if → valid false（合约违规）
+const r1b = checkSemantic('login', [
+  { kind: 'call', function: 'verify_password', args: [], assignTo: 'ok' }
+]);
+assert(r1b.valid === false && r1b.errors.some(e => e.includes('verify_password')), 'must_be_checked: 返回值未用于 if 拦截', r1b.errors.join('; '));
+
+// 1c. 未使用 assignTo 保存返回值 → valid false
+const r1c = checkSemantic('login', [
+  { kind: 'call', function: 'verify_password', args: [] }
+]);
+assert(r1c.valid === false && r1c.errors.some(e => e.includes('未使用assignTo')), 'must_be_checked: 未使用 assignTo 拦截', r1c.errors.join('; '));
+
+// ============================================================
+// 2. sequence_after
+// ============================================================
+console.log('\n--- sequence_after ---');
+
+checkSemantic = reloadChecker();
+
+writeIr([{
+  name: 'generate_jwt',
+  contracts: [{ type: 'sequence_after', function: 'verify_password', description: '签发令牌前必须先验证密码' }]
+}]);
+
+// 2a. verify_password 在 generate_jwt 之前 → valid true
+const r2a = checkSemantic('login', [
+  { kind: 'call', function: 'verify_password', args: [], assignTo: 'ok' },
+  { kind: 'if', condition: 'ok', thenActions: [
+    { kind: 'call', function: 'generate_jwt', args: [] }
+  ]}
+]);
+assert(r2a.valid === true, 'sequence_after: 先验证后签发通过', '');
+
+// 2b. generate_jwt 在 verify_password 之前 → valid false
+const r2b = checkSemantic('login', [
+  { kind: 'call', function: 'generate_jwt', args: [] },
+  { kind: 'call', function: 'verify_password', args: [], assignTo: 'ok' }
+]);
+assert(r2b.valid === false && r2b.errors.some(e => e.includes('generate_jwt')), 'sequence_after: 跳过验证直接签发拦截', r2b.errors.join('; '));
+
+// 2c. verify_password 从未被调用 → valid false
+const r2c = checkSemantic('login', [
+  { kind: 'call', function: 'generate_jwt', args: [] }
+]);
+assert(r2c.valid === false && r2c.errors.some(e => e.includes('generate_jwt')), 'sequence_after: 缺少前置函数拦截', r2c.errors.join('; '));
+
+// 2d. 链式依赖 A→B→C（C 需要在 B 之后，但 B 在 C 之后出现）
+checkSemantic = reloadChecker();
+writeIr([{
+  name: 'C',
+  contracts: [{ type: 'sequence_after', function: 'B', description: 'C 必须在 B 之后' }]
+}]);
+const r2d = checkSemantic('test', [
+  { kind: 'call', function: 'A', args: [] },
+  { kind: 'call', function: 'C', args: [] },
+  { kind: 'call', function: 'B', args: [] }
+]);
+assert(r2d.valid === false && r2d.errors.some(e => e.includes('C')), 'sequence_after: 链式依赖 A→B→C 拦截', r2d.errors.join('; '));
+
+// ============================================================
+// 3. param_from
+// ============================================================
+console.log('\n--- param_from ---');
+
+checkSemantic = reloadChecker();
+
+writeIr([{
+  name: 'create_session',
+  params: [{ name: 'token', type: 'str' }],
+  contracts: [{ type: 'param_from', param: 'token', function: 'generate_jwt', description: 'session 的 token 必须来自 generate_jwt' }]
+}]);
+
+// 3a. token 来自 generate_jwt 的输出 → valid true
+const r3a = checkSemantic('login', [
+  { kind: 'call', function: 'generate_jwt', args: [], assignTo: 'jwt' },
+  { kind: 'call', function: 'create_session', args: [{ name: 'token', type: 'str', value: 'jwt' }] }
+]);
+assert(r3a.valid === true, 'param_from: token 来自 generate_jwt 通过', '');
+
+// 3b. token 不来自 generate_jwt → valid false
+const r3b = checkSemantic('login', [
+  { kind: 'call', function: 'generate_jwt', args: [], assignTo: 'other' },
+  { kind: 'call', function: 'create_session', args: [{ name: 'token', type: 'str', value: 'manual_token' }] }
+]);
+assert(r3b.valid === false && r3b.errors.some(e => e.includes('create_session')), 'param_from: token 不来自 generate_jwt 拦截', r3b.errors.join('; '));
+
+// 3c. generate_jwt 从未被调用 → valid false
+const r3c = checkSemantic('login', [
+  { kind: 'call', function: 'create_session', args: [{ name: 'token', type: 'str', value: 'jwt' }] }
+]);
+assert(r3c.valid === false && r3c.errors.some(e => e.includes('create_session')), 'param_from: generate_jwt 未调用拦截', r3c.errors.join('; '));
+
+// 3d. 多级传递 A→B→C（C 的 input 必须来自 B，但实际来自 A）
+checkSemantic = reloadChecker();
+writeIr([{
+  name: 'C',
+  params: [{ name: 'input', type: 'str' }],
+  contracts: [{ type: 'param_from', param: 'input', function: 'B', description: 'C 的 input 必须来自 B' }]
+}]);
+const r3d = checkSemantic('test', [
+  { kind: 'call', function: 'A', args: [], assignTo: 'a_val' },
+  { kind: 'call', function: 'C', args: [{ name: 'input', type: 'str', value: 'a_val' }] }
+]);
+assert(r3d.valid === false && r3d.errors.some(e => e.includes('C')), 'param_from: 多级传递 A→C 跳过 B 拦截', r3d.errors.join('; '));
+
+// ============================================================
+// 4. when_intent
+// ============================================================
+console.log('\n--- when_intent ---');
+
+checkSemantic = reloadChecker();
+
+writeIr([{
+  name: 'send_otp',
+  contracts: [{ type: 'must_be_checked', when_intent: ['login', 'signin'], description: '登录场景下 OTP 结果必须检查' }]
+}]);
+
+// 4a. 意图匹配时合约生效 → valid false
+const r4a = checkSemantic('user login flow', [
+  { kind: 'call', function: 'send_otp', args: [], assignTo: 'code' }
+]);
+assert(r4a.valid === false && r4a.errors.some(e => e.includes('send_otp')), 'when_intent: 意图匹配时合约生效', r4a.errors.join('; '));
+
+// 4b. 意图不匹配时合约静默跳过 → valid true
+const r4b = checkSemantic('query report data', [
+  { kind: 'call', function: 'send_otp', args: [], assignTo: 'code' }
+]);
+assert(r4b.valid === true, 'when_intent: 意图不匹配时合约跳过', '');
+
+// 4c. when_intent 未设置时始终生效
+checkSemantic = reloadChecker();
+writeIr([{
+  name: 'check_access',
+  contracts: [{ type: 'must_be_checked', description: '访问检查结果必须用于条件判断' }]
+}]);
+const r4c = checkSemantic('any intent here', [
+  { kind: 'call', function: 'check_access', args: [], assignTo: 'result' }
+]);
+assert(r4c.valid === false && r4c.errors.some(e => e.includes('check_access')), 'when_intent: 未设置时始终生效', r4c.errors.join('; '));
+
+// ============================================================
+// 5. require_param
+// ============================================================
+console.log('\n--- require_param ---');
+
+checkSemantic = reloadChecker();
+
+writeIr([{
+  name: 'send_email',
+  params: [{ name: 'to', type: 'str' }],
+  contracts: [{ type: 'require_param', param: 'to', not_empty: true, description: '收件人地址不能为空' }]
+}]);
+
+// 5a. 参数为空模板 → valid false
+const r5a = checkSemantic('send', [
+  { kind: 'call', function: 'send_email', args: [{ name: 'to', type: 'str', value: '{}' }] }
+]);
+assert(r5a.valid === false && r5a.errors.some(e => e.includes('send_email')), 'require_param: 空模板参数拦截', r5a.errors.join('; '));
+
+// 5b. 参数为空字符串 → valid false
+const r5b = checkSemantic('send', [
+  { kind: 'call', function: 'send_email', args: [{ name: 'to', type: 'str', value: '' }] }
+]);
+assert(r5b.valid === false && r5b.errors.some(e => e.includes('send_email')), 'require_param: 空字符串拦截', r5b.errors.join('; '));
+
+// 5c. 参数正常 → valid true
+const r5c = checkSemantic('send', [
+  { kind: 'call', function: 'send_email', args: [{ name: 'to', type: 'str', value: 'user@example.com' }] }
+]);
+assert(r5c.valid === true, 'require_param: 正常参数通过', '');
+
+// ============================================================
+// 6. 组合合约
+// ============================================================
+console.log('\n--- 组合合约 ---');
+
+checkSemantic = reloadChecker();
+
+writeIr([{
+  name: 'process_payment',
+  params: [{ name: 'amount', type: 'int' }],
+  contracts: [
+    { type: 'sequence_after', function: 'validate_user', description: '支付前必须验证用户' },
+    { type: 'must_be_checked', description: '支付结果必须检查' }
+  ]
+}]);
+
+// 6a. 两个合约都违规 → valid false
+const r6a = checkSemantic('pay', [
+  { kind: 'call', function: 'process_payment', args: [{ name: 'amount', type: 'int', value: 100 }], assignTo: 'pay_result' }
+]);
+assert(r6a.valid === false && r6a.errors.length >= 1, '组合合约: 两个都违规拦截', r6a.errors.join('; '));
+
+// 6b. 两个合约都满足 → valid true
+const r6b = checkSemantic('pay', [
+  { kind: 'call', function: 'validate_user', args: [] },
+  { kind: 'call', function: 'process_payment', args: [{ name: 'amount', type: 'int', value: 100 }], assignTo: 'pay_result' },
+  { kind: 'if', condition: 'pay_result', thenActions: [] }
+]);
+assert(r6b.valid === true, '组合合约: 都满足时通过', '');
+
+// ============================================================
+// 报告
+// ============================================================
+console.log('\n========================================');
+console.log(`结果: ${results.pass}/${results.total} 通过`);
+console.log('========================================\n');
+
+results.details.forEach(d => {
+  console.log(`  ${d.status} ${d.name}`);
+  if (d.detail) console.log(`     ${d.detail}`);
+});
+
+const passRate = (results.pass / results.total * 100).toFixed(0);
+console.log(`\n通过率: ${passRate}%`);
+process.exit(results.fail > 0 ? 1 : 0);

package/test_ssg_stress.js

@@ -0,0 +1,156 @@
+/**
+ * SSG 状态机压力测试
+ * ==================
+ * 测试大规模状态图下的性能
+ */
+
+const { StateMachineValidator } = require('./dist/ssg-validator.js');
+
+const results = { pass: 0, fail: 0, total: 0, details: [] };
+
+function assert(condition, name, detail) {
+  results.total++;
+  if (condition) { results.pass++; results.details.push({ name, status: '✅', detail }); }
+  else { results.fail++; results.details.push({ name, status: '❌', detail }); }
+}
+
+console.log('🧪 SSG 状态机压力测试\n');
+
+// ============================================================
+// 1. 大规模状态图（20 个状态，30 条跃迁）
+// ============================================================
+console.log('--- 大规模状态图 (20 states, 30 transitions) ---');
+
+const states = [];
+for (let i = 0; i < 20; i++) states.push(`S${i}`);
+
+const protocols = [];
+for (let i = 0; i < 19; i++) {
+  protocols.push({
+    function: `step_${i}`,
+    protocol: { pre_states: [states[i]], post_states: [states[i+1]], invalidate: [states[i]] }
+  });
+}
+// 添加一些跨层跃迁
+protocols.push({
+  function: 'jump',
+  protocol: { pre_states: ['S0'], post_states: ['S10'], invalidate: ['S0'] }
+});
+
+const start = Date.now();
+const ssv = new StateMachineValidator(protocols, 'S0');
+for (let i = 0; i < 19; i++) {
+  const r = ssv.apply(`step_${i}`);
+  if (!r.valid) { console.log(`  失败于 step_${i}: ${r.error}`); break; }
+}
+const linearTime = Date.now() - start;
+assert(linearTime < 100, '大规模状态图: 线性跃迁耗时 < 100ms', `${linearTime}ms`);
+
+// ============================================================
+// 2. 非法跃迁检测性能（1000 次调用）
+// ============================================================
+console.log('\n--- 非法跃迁检测 (1000次) ---');
+
+const ssv2 = new StateMachineValidator(protocols, 'S0');
+const start2 = Date.now();
+let illegalCount = 0;
+for (let i = 0; i < 1000; i++) {
+  const r = ssv2.apply('jump');
+  if (!r.valid) illegalCount++;
+}
+const illegalTime = Date.now() - start2;
+assert(illegalTime < 500, '非法跃迁检测: 1000 次耗时 < 500ms', `${illegalTime}ms, 拦截 ${illegalCount} 次`);
+
+// ============================================================
+// 3. findMissingSteps 性能（复杂图）
+// ============================================================
+console.log('\n--- findMissingSteps 性能 ---');
+
+// 构建分支状态图：S0 → S1/S2 → S3/S4 → S5
+const branchProtocols = [
+  { function: 'to_S1', protocol: { pre_states: ['S0'], post_states: ['S1'], invalidate: ['S0'] } },
+  { function: 'to_S2', protocol: { pre_states: ['S0'], post_states: ['S2'], invalidate: ['S0'] } },
+  { function: 'to_S3', protocol: { pre_states: ['S1'], post_states: ['S3'], invalidate: ['S1'] } },
+  { function: 'to_S4', protocol: { pre_states: ['S2'], post_states: ['S4'], invalidate: ['S2'] } },
+  { function: 'to_S5', protocol: { pre_states: ['S3', 'S4'], post_states: ['S5'] } },
+  // 非法跃迁（用于触发 findMissingSteps）
+  { function: 'illegal_final', protocol: { pre_states: ['S5'], post_states: ['DONE'] } },
+];
+
+const ssv3 = new StateMachineValidator(branchProtocols, 'S0');
+const start3 = Date.now();
+const r3 = ssv3.apply('illegal_final');
+const missingTime = Date.now() - start3;
+assert(r3.valid === false && missingTime < 50, 'findMissingSteps: 分支图耗时 < 50ms', `${missingTime}ms`);
+
+// ============================================================
+// 4. 空规则处理
+// ============================================================
+console.log('\n--- 空规则处理 ---');
+
+const ssv4 = new StateMachineValidator([], 'INIT');
+const r4 = ssv4.apply('any_function');
+assert(r4.valid === true, '空规则: 任意函数通过', '');
+
+// ============================================================
+// 5. 超大规则集（100 条规则）
+// ============================================================
+console.log('\n--- 超大规则集 (100 rules) ---');
+
+const manyRules = [];
+for (let i = 0; i < 100; i++) {
+  manyRules.push({
+    function: `func_${i}`,
+    protocol: { pre_states: [`PRE_${i}`], post_states: [`POST_${i}`] }
+  });
+}
+const start5 = Date.now();
+const ssv5 = new StateMachineValidator(manyRules, 'PRE_0');
+const r5a = ssv5.apply('func_0');
+const r5b = ssv5.apply('func_99');
+const manyTime = Date.now() - start5;
+assert(r5a.valid === true && r5b.valid === false, '超大规则集: 100 规则初始化+2次调用', `${manyTime}ms`);
+
+// ============================================================
+// 6. 状态膨胀（同时处于多个状态）
+// ============================================================
+console.log('\n--- 多状态并发 ---');
+
+// 注意：grant_role_a/b/c 不移除 INIT，因为需要允许多角色同时存在
+const multiStateProtocols = [
+  { function: 'grant_role_a', protocol: { pre_states: ['INIT'], post_states: ['ROLE_A'] } },
+  { function: 'grant_role_b', protocol: { pre_states: ['INIT'], post_states: ['ROLE_B'] } },
+  { function: 'grant_role_c', protocol: { pre_states: ['INIT'], post_states: ['ROLE_C'] } },
+  { function: 'access_admin', protocol: { pre_states: ['ROLE_A', 'ROLE_B'], post_states: ['ADMIN'] } },
+];
+const ssv6 = new StateMachineValidator(multiStateProtocols, 'INIT');
+ssv6.apply('grant_role_a');
+ssv6.apply('grant_role_b');
+const r6a = ssv6.apply('access_admin');
+assert(r6a.valid === true, '多状态并发: 同时拥有 ROLE_A+ROLE_B 可访问 admin', 'states: ' + ssv6.getCurrentStates().join(','));
+
+const ssv6b = new StateMachineValidator(multiStateProtocols, 'INIT');
+ssv6b.apply('grant_role_a');
+const r6b = ssv6b.apply('access_admin');
+assert(r6b.valid === false, '多状态并发: 只有 ROLE_A 无法访问 admin', '需要 [ROLE_A,ROLE_B]，当前状态: ' + ssv6b.getCurrentStates().join(','));
+
+// 验证所有三个角色都授予后才能访问
+const ssv6c = new StateMachineValidator(multiStateProtocols, 'INIT');
+ssv6c.apply('grant_role_a');
+ssv6c.apply('grant_role_b');
+ssv6c.apply('grant_role_c');
+const r6c = ssv6c.apply('access_admin');
+assert(r6c.valid === true, '多状态并发: ROLE_A+ROLE_B+ROLE_C 可访问 admin', 'states: ' + ssv6c.getCurrentStates().join(','));
+
+// ============================================================
+// 报告
+// ============================================================
+console.log('\n========================================');
+console.log(`结果: ${results.pass}/${results.total} 通过`);
+console.log('========================================\n');
+
+results.details.forEach(d => console.log(`  ${d.status} ${d.name}${d.detail ? ' (' + d.detail + ')' : ''}`));
+
+const passRate = (results.pass / results.total * 100).toFixed(0);
+console.log(`\n通过率: ${passRate}%`);
+process.exit(results.fail > 0 ? 1 : 0);