@bolloon/bolloon-agent 0.1.0

package/src/test/bollharness-integration.test.ts

@@ -0,0 +1,398 @@
+/**
+ * Bollharness Integration Tests - Standalone Component Tests
+ * 
+ * These tests verify the core bollharness integration components
+ * without requiring full constraint-runtime dependency chain.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+
+// ==================== Gate State Machine Tests ====================
+
+interface GateConfig {
+  entryCondition: string;
+  requiredArtifact: string;
+  requiredNextSkill: string;
+  requiredReviewSubstrate?: string;
+  isReviewGate: boolean;
+}
+
+type Gate = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+
+const GATE_CONFIGS: Record<Gate, GateConfig> = {
+  0: { entryCondition: '用户提出需求', requiredArtifact: '问题陈述', requiredNextSkill: 'arch', isReviewGate: false },
+  1: { entryCondition: 'Gate 0 产物存在', requiredArtifact: 'ADR草稿', requiredNextSkill: 'arch', isReviewGate: false },
+  2: { entryCondition: 'ADR草稿完成', requiredArtifact: '审查报告', requiredNextSkill: 'review', requiredReviewSubstrate: 'ref-review-sop.md', isReviewGate: true },
+  3: { entryCondition: 'Gate 2 PASS', requiredArtifact: 'PLAN文档', requiredNextSkill: 'harness-eng', isReviewGate: false },
+  4: { entryCondition: 'PLAN vN-final冻结', requiredArtifact: '审查报告', requiredNextSkill: 'review', requiredReviewSubstrate: 'ref-review-sop.md', isReviewGate: true },
+  5: { entryCondition: 'Gate 4 PASS', requiredArtifact: 'WP拆分+TASK.md', requiredNextSkill: 'task-arch', isReviewGate: false },
+  6: { entryCondition: '全部TASK.md完成', requiredArtifact: '审查报告', requiredNextSkill: 'review', requiredReviewSubstrate: 'ref-review-sop.md', isReviewGate: true },
+  7: { entryCondition: 'Gate 6 PASS', requiredArtifact: '代码+LOG.md', requiredNextSkill: 'harness-eng', isReviewGate: false },
+  8: { entryCondition: '全部WP代码+LOG.md存在', requiredArtifact: '审查报告', requiredNextSkill: 'harness-eng-test', requiredReviewSubstrate: 'ref-review-sop.md', isReviewGate: true },
+};
+
+describe('GateStateMachine', () => {
+  let currentGate: Gate = 0;
+  let artifacts: Map<string, unknown> = new Map();
+
+  describe('initialization', () => {
+    it('should start at gate 0', () => {
+      currentGate = 0;
+      expect(currentGate).toBe(0);
+    });
+
+    it('should have correct gate 0 config', () => {
+      const config = GATE_CONFIGS[0];
+      expect(config.requiredArtifact).toBeDefined();
+      expect(config.isReviewGate).toBe(false);
+    });
+  });
+
+  describe('gate configs', () => {
+    it('should have 9 gates defined', () => {
+      expect(Object.keys(GATE_CONFIGS).length).toBe(9);
+    });
+
+    it('should have 4 review gates (2,4,6,8)', () => {
+      expect(GATE_CONFIGS[2].isReviewGate).toBe(true);
+      expect(GATE_CONFIGS[4].isReviewGate).toBe(true);
+      expect(GATE_CONFIGS[6].isReviewGate).toBe(true);
+      expect(GATE_CONFIGS[8].isReviewGate).toBe(true);
+    });
+
+    it('should have correct next skill for each gate', () => {
+      expect(GATE_CONFIGS[0].requiredNextSkill).toBe('arch');
+      expect(GATE_CONFIGS[5].requiredNextSkill).toBe('task-arch');
+    });
+  });
+
+  describe('artifacts', () => {
+    it('should be able to submit artifacts', () => {
+      artifacts.set('test', { data: 'test' });
+      expect(artifacts.has('test')).toBe(true);
+    });
+
+    it('should retrieve submitted artifacts', () => {
+      artifacts.set('adr', { content: 'ADR draft' });
+      const artifact = artifacts.get('adr');
+      expect(artifact).toBeDefined();
+    });
+  });
+});
+
+// ==================== Guard Router Tests ====================
+
+const GUARD_MAP: Record<string, string[]> = {
+  'src/agents/': ['check_api_types', 'check_skill_parity'],
+  'src/documents/': ['check_doc_freshness', 'check_api_types'],
+  'src/network/': ['check_api_types', 'check_versions'],
+  'docs/': ['check_doc_freshness', 'check_doc_links'],
+  'CLAUDE.md': ['check_doc_freshness', 'check_artifact_link'],
+  'docs/decisions/': ['check_artifact_link', 'check_versions'],
+  'src/test/': ['check_api_types', 'check_versions'],
+};
+
+function route(filePath: string): string[] {
+  const matched: string[] = [];
+  const sortedPatterns = Object.keys(GUARD_MAP).sort((a, b) => b.length - a.length);
+
+  for (const pattern of sortedPatterns) {
+    if (filePath.startsWith(pattern) || filePath === pattern.replace(/\/$/, '')) {
+      matched.push(...GUARD_MAP[pattern]);
+    }
+  }
+
+  return [...new Set(matched)];
+}
+
+describe('GuardRouter', () => {
+  describe('routing', () => {
+    it('should route agents path to check_api_types', () => {
+      const guards = route('src/agents/pi-sdk.ts');
+      expect(guards).toContain('check_api_types');
+    });
+
+    it('should route docs path to doc freshness', () => {
+      const guards = route('docs/guide.md');
+      expect(guards).toContain('check_doc_freshness');
+    });
+
+    it('should route decisions to artifact link check', () => {
+      const guards = route('docs/decisions/adr-001.md');
+      expect(guards).toContain('check_artifact_link');
+    });
+
+    it('should route test files to version check', () => {
+      const guards = route('src/test/pi-sdk.test.ts');
+      expect(guards).toContain('check_versions');
+    });
+
+    it('should return empty array for unknown paths', () => {
+      const guards = route('src/unknown/file.ts');
+      expect(guards.length).toBe(0);
+    });
+
+    it('should handle CLAUDE.md special case', () => {
+      const guards = route('CLAUDE.md');
+      expect(guards).toContain('check_doc_freshness');
+      expect(guards).toContain('check_artifact_link');
+    });
+  });
+
+  describe('deduplication', () => {
+    it('should deduplicate guard names', () => {
+      const guards = route('src/agents/pi-sdk.ts');
+      const uniqueGuards = [...new Set(guards)];
+      expect(guards.length).toBe(uniqueGuards.length);
+    });
+  });
+});
+
+// ==================== Context Router Tests ====================
+
+const CONTEXT_MAP: Record<string, string[]> = {
+  'src/agents/': ['agent-architecture', 'multi-agent-patterns'],
+  'src/documents/': ['document-processing', 'parser-patterns'],
+  'src/network/': ['p2p-protocols', 'connection-patterns'],
+  'docs/': ['documentation-standards'],
+  'docs/decisions/': ['decision-tracking', 'adr-patterns'],
+  'src/test/': ['testing-patterns', 'quality-standards'],
+  'CLAUDE.md': ['project-governance', 'truth-source-hierarchy'],
+};
+
+const FALLBACK_FRAGMENTS = ['general-dev-principles', 'code-quality'];
+
+function match(filePath: string): string[] {
+  if (!filePath) return [];
+  const normalized = filePath.replace(/\\/g, '/');
+  const matched: string[] = [];
+  const sortedPatterns = Object.keys(CONTEXT_MAP).sort((a, b) => b.length - a.length);
+
+  for (const pattern of sortedPatterns) {
+    if (normalized.startsWith(pattern) || normalized.endsWith(pattern)) {
+      matched.push(...CONTEXT_MAP[pattern]);
+    }
+  }
+
+  return [...new Set(matched)];
+}
+
+describe('ContextRouter', () => {
+  describe('matching', () => {
+    it('should match agents path', () => {
+      const fragments = match('src/agents/protocol.ts');
+      expect(fragments).toContain('agent-architecture');
+      expect(fragments).toContain('multi-agent-patterns');
+    });
+
+    it('should match docs path', () => {
+      const fragments = match('docs/api.md');
+      expect(fragments).toContain('documentation-standards');
+    });
+
+    it('should match decisions path', () => {
+      const fragments = match('docs/decisions/adr-001.md');
+      expect(fragments).toContain('decision-tracking');
+      expect(fragments).toContain('adr-patterns');
+    });
+
+    it('should match CLAUDE.md', () => {
+      const fragments = match('CLAUDE.md');
+      expect(fragments).toContain('project-governance');
+    });
+
+    it('should return empty for invalid paths', () => {
+      const fragments = match('');
+      expect(fragments.length).toBe(0);
+    });
+  });
+
+  describe('fallback fragments', () => {
+    it('should have fallback fragments defined', () => {
+      expect(FALLBACK_FRAGMENTS).toContain('general-dev-principles');
+      expect(FALLBACK_FRAGMENTS).toContain('code-quality');
+    });
+  });
+});
+
+// ==================== Skill Tests ====================
+
+interface Skill {
+  name: string;
+  description: string;
+  execute(params: Record<string, unknown>): Promise<string>;
+}
+
+// Mock skills for testing
+const skills: Record<string, Skill> = {
+  arch: {
+    name: 'arch',
+    description: 'Project architect. Architecture decisions and boundary freezing.',
+    async execute(params) {
+      const essence = `Core challenge: ${params.task || 'unspecified'}`;
+      const tensions = ['Simplicity vs Flexibility', 'Performance vs Maintainability'];
+      const alternatives = [
+        { name: 'Option A', tradeoffs: ['Fast', 'Limited'], recommendation: 'MVP' },
+        { name: 'Option B', tradeoffs: ['More work', 'Extensible'], recommendation: 'Long-term' }
+      ];
+      return JSON.stringify({ essence, tensions, alternatives }, null, 2);
+    }
+  },
+  lead: {
+    name: 'lead',
+    description: 'Development workflow commander. Fail-closed state machine.',
+    async execute(params) {
+      const action = params.action as string;
+      if (action === 'get_gate') {
+        return JSON.stringify({ current_gate: 0, gate_name: 'Problem Lock', required_artifact: '问题陈述' }, null, 2);
+      }
+      if (action === 'classify') {
+        const desc = params.description as string || '';
+        const isPolicy = desc.includes('policy');
+        const isContract = desc.includes('API') || desc.includes('contract');
+        return JSON.stringify({
+          classification: isPolicy ? 'policy' : isContract ? 'contract' : 'implementation',
+          fast_track: !isPolicy && !isContract
+        }, null, 2);
+      }
+      return JSON.stringify({ current_gate: 0 });
+    }
+  },
+  task_arch: {
+    name: 'task-arch',
+    description: 'Task decomposition. Breaks down PLAN into work packages.',
+    async execute(params) {
+      const workPackages = [
+        { id: 'WP-1', description: 'Core implementation', files: ['src/agents/*.ts'] },
+        { id: 'WP-2', description: 'Network layer', files: ['src/network/*.ts'] }
+      ];
+      return JSON.stringify({ workPackages }, null, 2);
+    }
+  }
+};
+
+describe('Skills', () => {
+  describe('arch skill', () => {
+    it('should have correct name and description', () => {
+      expect(skills.arch.name).toBe('arch');
+      expect(skills.arch.description).toContain('architect');
+    });
+
+    it('should execute and return analysis', async () => {
+      const result = await skills.arch.execute({ task: 'design new feature' });
+      const parsed = JSON.parse(result);
+      expect(parsed.essence).toBeDefined();
+      expect(parsed.tensions).toHaveLength(2);
+      expect(parsed.alternatives).toHaveLength(2);
+    });
+  });
+
+  describe('lead skill', () => {
+    it('should have correct name', () => {
+      expect(skills.lead.name).toBe('lead');
+    });
+
+    it('should get gate pack', async () => {
+      const result = await skills.lead.execute({ action: 'get_gate' });
+      const parsed = JSON.parse(result);
+      expect(parsed.current_gate).toBe(0);
+    });
+
+    it('should classify policy changes', async () => {
+      const result = await skills.lead.execute({ action: 'classify', description: 'change policy boundary' });
+      const parsed = JSON.parse(result);
+      expect(parsed.classification).toBe('policy');
+    });
+
+    it('should classify contract changes', async () => {
+      const result = await skills.lead.execute({ action: 'classify', description: 'change API contract' });
+      const parsed = JSON.parse(result);
+      expect(parsed.classification).toBe('contract');
+    });
+
+    it('should classify implementation changes as fast-track eligible', async () => {
+      const result = await skills.lead.execute({ action: 'classify', description: 'fix bug' });
+      const parsed = JSON.parse(result);
+      expect(parsed.classification).toBe('implementation');
+      expect(parsed.fast_track).toBe(true);
+    });
+  });
+
+  describe('task-arch skill', () => {
+    it('should decompose plan into work packages', async () => {
+      const result = await skills.task_arch.execute({ plan: 'implement feature' });
+      const parsed = JSON.parse(result);
+      expect(parsed.workPackages).toHaveLength(2);
+      expect(parsed.workPackages[0].id).toBe('WP-1');
+    });
+  });
+});
+
+// ==================== Change Classification Tests ====================
+
+describe('Change Classification', () => {
+  function classifyChange(description: string): { classification: string; fast_track: boolean } {
+    const isPolicy = description.includes('policy') || description.includes('boundary');
+    const isContract = description.includes('API') || description.includes('contract') || description.includes('schema');
+    const isImplementation = !isPolicy && !isContract;
+
+    return {
+      classification: isPolicy ? 'policy' : isContract ? 'contract' : 'implementation',
+      fast_track: isImplementation
+    };
+  }
+
+  it('should classify policy changes', () => {
+    const result = classifyChange('change policy boundary');
+    expect(result.classification).toBe('policy');
+    expect(result.fast_track).toBe(false);
+  });
+
+  it('should classify contract changes', () => {
+    const result = classifyChange('change API contract');
+    expect(result.classification).toBe('contract');
+    expect(result.fast_track).toBe(false);
+  });
+
+  it('should classify implementation changes', () => {
+    const result = classifyChange('fix bug in code');
+    expect(result.classification).toBe('implementation');
+    expect(result.fast_track).toBe(true);
+  });
+
+  it('should classify schema changes as contract', () => {
+    const result = classifyChange('update database schema');
+    expect(result.classification).toBe('contract');
+  });
+});
+
+// ==================== Integration Configuration Tests ====================
+
+describe('BollharnessConfig', () => {
+  interface BollharnessConfig {
+    enabled: boolean;
+    guardsEnabled: boolean;
+    contextEnabled: boolean;
+    skillsEnabled: boolean;
+    gatesEnabled: boolean;
+  }
+
+  function createDefaultConfig(): BollharnessConfig {
+    return {
+      enabled: true,
+      guardsEnabled: true,
+      contextEnabled: true,
+      skillsEnabled: true,
+      gatesEnabled: true,
+    };
+  }
+
+  it('should have default config with all features enabled', () => {
+    const config = createDefaultConfig();
+    expect(config.enabled).toBe(true);
+    expect(config.guardsEnabled).toBe(true);
+    expect(config.contextEnabled).toBe(true);
+    expect(config.skillsEnabled).toBe(true);
+    expect(config.gatesEnabled).toBe(true);
+  });
+});

package/src/test/channel-agent-multi-dialogue.ts

@@ -0,0 +1,265 @@
+/**
+ * Channel Agent Multi-Turn Dialogue Test
+ *
+ * 测试场景：
+ * 1. 两个 Channel Agent (Alice/Bob) 之间的多轮对话
+ * 2. 基于判断力的 Harness 调用 (Gate 1-8)
+ * 3. 上下文感知的 Gate 选择
+ * 4. Persona 设计能力
+ *
+ * 运行: npx tsx src/test/channel-agent-multi-dialogue.ts
+ */
+
+import { config } from 'dotenv';
+import { ChannelAgent, createChannelAgent, ChannelAgentRegistry } from '../social/channels/channel-agent-session.js';
+import type { PersonaDesignRequest } from '../social/persona/enhanced-persona.js';
+
+config();
+
+const PORT_ALICE = 8001;
+const PORT_BOB = 8002;
+
+interface DialogScript {
+  from: string;
+  to: string;
+  content: string;
+  expectHarness: boolean;
+  expectGate?: number;
+}
+
+async function testMultiTurnDialogue() {
+  console.log('\n========================================');
+  console.log('  Channel Agent 多轮对话测试');
+  console.log('  场景: 完成一个用户认证系统的需求讨论');
+  console.log('========================================\n');
+
+  // 创建 Agent 注册表
+  const registry = new ChannelAgentRegistry();
+
+  // 创建 Alice
+  const alice = createChannelAgent({
+    name: 'Alice',
+    port: PORT_ALICE,
+    domain: '架构',
+    capabilities: ['架构设计', '代码审查', '任务分解']
+  });
+
+  // 创建 Bob
+  const bob = createChannelAgent({
+    name: 'Bob',
+    port: PORT_BOB,
+    domain: '开发',
+    capabilities: ['代码编写', '调试', '测试']
+  });
+
+  // 注册
+  registry.register(alice);
+  registry.register(bob);
+
+  // 设计 persona
+  alice.designPersona({
+    name: 'Alice',
+    type: 'developer',
+    domain: '架构',
+    tone: 'professional'
+  });
+
+  bob.designPersona({
+    name: 'Bob',
+    type: 'developer',
+    domain: '开发',
+    tone: 'technical'
+  });
+
+  // 启动
+  await alice.start();
+  await bob.start();
+
+  // 对话脚本
+  const script: DialogScript[] = [
+    // 第1轮 - 架构讨论
+    { from: 'Alice', to: 'Bob', content: 'Bob，我们需要设计一个新的用户认证系统。', expectHarness: false },
+    { from: 'Bob', to: 'Alice', content: '好的，具体需要哪些功能？', expectHarness: false },
+
+    // 第2轮 - 需求讨论
+    { from: 'Alice', to: 'Bob', content: '需要登录、注册、找回密码，还要支持社交登录。', expectHarness: false },
+    { from: 'Bob', to: 'Alice', content: '明白了。这个系统需要什么级别的安全性？', expectHarness: false },
+
+    // 第3轮 - 安全讨论 → Gate 4
+    { from: 'Alice', to: 'Bob', content: '需要处理金融数据，所以安全性很重要。请检查一下架构设计。', expectHarness: true, expectGate: 4 },
+    { from: 'Bob', to: 'Alice', content: '好的，我来分析一下架构设计，看看有没有安全风险。', expectHarness: true, expectGate: 1 },
+
+    // 第4轮 - 代码审查 → Gate 2
+    { from: 'Alice', to: 'Bob', content: '架构看起来不错。帮我 review 一下登录模块的实现。', expectHarness: true, expectGate: 2 },
+    { from: 'Bob', to: 'Alice', content: '好的，让我检查登录模块的代码实现。', expectHarness: true, expectGate: 2 },
+
+    // 第5轮 - 优化讨论
+    { from: 'Alice', to: 'Bob', content: '代码审查发现了一些问题，需要优化错误处理。', expectHarness: false },
+    { from: 'Bob', to: 'Alice', content: '同意，错误处理需要改进。', expectHarness: false },
+
+    // 第6轮 - 任务分解 → Gate 5
+    { from: 'Alice', to: 'Bob', content: '好的，现在我们来分解任务，制定开发计划。', expectHarness: true, expectGate: 5 },
+    { from: 'Bob', to: 'Alice', content: '我来帮你把任务分解成可执行的小块。', expectHarness: true, expectGate: 5 },
+
+    // 第7轮 - 开始实现
+    { from: 'Alice', to: 'Bob', content: '任务分解得很好。我们开始实现第一个任务吧。', expectHarness: false },
+    { from: 'Bob', to: 'Alice', content: '好的，开始实现登录模块。', expectHarness: false },
+
+    // 第8轮 - 代码实现 → Gate 7
+    { from: 'Alice', to: 'Bob', content: '实现完成，帮我优化一下代码质量。', expectHarness: true, expectGate: 7 },
+    { from: 'Bob', to: 'Alice', content: '好的，我来进行代码优化。', expectHarness: true, expectGate: 7 },
+
+    // 第9轮 - 测试验证 → Gate 8
+    { from: 'Alice', to: 'Bob', content: '代码优化完成，帮我验证一下质量。', expectHarness: true, expectGate: 8 },
+    { from: 'Bob', to: 'Alice', content: '好的，我来运行测试验证。', expectHarness: true, expectGate: 8 },
+
+    // 第10轮 - 完成
+    { from: 'Alice', to: 'Bob', content: '测试通过了！继续下一个任务。', expectHarness: false },
+    { from: 'Bob', to: 'Alice', content: '太好了！继续加油。', expectHarness: false },
+  ];
+
+  console.log('━━━ 开始多轮对话 ━━━\n');
+
+  let harnessCallCount = 0;
+  const gateStats = new Map<number, number>();
+
+  for (let i = 0; i < script.length; i++) {
+    const { from, to, content, expectHarness, expectGate } = script[i];
+    const targetPort = from === 'Alice' ? PORT_BOB : PORT_ALICE;
+
+    console.log(`━━━ 第 ${Math.floor(i / 2) + 1} 轮 ━━━`);
+    console.log(`[${from}] >>> ${content}`);
+
+    try {
+      const resp = await fetch(`http://localhost:${targetPort}/receive`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ fromName: from, content })
+      });
+
+      const result = await resp.json();
+
+      console.log(`\n[${to}] 处理结果:`);
+      if (result.harnessCalled) {
+        console.log(`   🧠 调用 Harness: Gate ${result.gate}`);
+        console.log(`   📋 Skills: ${result.skills?.join(', ') || '无'}`);
+        harnessCallCount++;
+        gateStats.set(result.gate, (gateStats.get(result.gate) || 0) + 1);
+
+        if (expectHarness && result.gate !== expectGate) {
+          console.log(`   ⚠️ 期望 Gate ${expectGate}，实际 ${result.gate}`);
+        }
+      } else {
+        console.log(`   🧠 普通对话 (无需 Harness)`);
+      }
+
+      console.log(`   📤 回复: ${result.response?.substring(0, 80)}...`);
+
+      // 等待一下再继续
+      await new Promise(r => setTimeout(r, 300));
+
+    } catch (err) {
+      console.log(`   ❌ 发送失败:`, err);
+    }
+
+    console.log('');
+  }
+
+  // 结果汇总
+  console.log('━━━ 结果汇总 ━━━\n');
+
+  console.log(`[Alice] 对话数: ${alice.getDialogHistory().length}`);
+  console.log(`[Bob] 对话数: ${bob.getDialogHistory().length}`);
+
+  console.log(`\nHarness 调用次数: ${harnessCallCount}`);
+
+  console.log('\nGate 统计:');
+  for (const [gate, count] of Array.from(gateStats.entries()).sort((a, b) => a[0] - b[0])) {
+    const gateNames: Record<number, string> = {
+      1: '架构设计',
+      2: '代码审查',
+      4: '安全检查',
+      5: '任务分解',
+      7: '代码实现',
+      8: '测试验证'
+    };
+    console.log(`  Gate ${gate} (${gateNames[gate] || '未知'}): ${count} 次`);
+  }
+
+  // 健康检查
+  console.log('\n━━━ 最终状态 ━━━\n');
+  const aliceHealth = await fetch(`http://localhost:${PORT_ALICE}/health`).then(r => r.json());
+  const bobHealth = await fetch(`http://localhost:${PORT_BOB}/health`).then(r => r.json());
+
+  console.log(`[Alice] DID: ${aliceHealth.id.substring(0, 16)}...`);
+  console.log(`[Bob]   DID: ${bobHealth.id.substring(0, 16)}...`);
+  console.log(`\n对话总数: ${aliceHealth.dialogCount + bobHealth.dialogCount}`);
+  console.log(`Harness 调用: ${harnessCallCount} 次`);
+
+  const success = harnessCallCount >= 6;
+  console.log(`\n${success ? '✅' : '⚠️'} ${success ? '测试成功' : '测试部分成功'}`);
+
+  // 清理
+  registry.clear();
+
+  console.log('\n========================================\n');
+
+  return success;
+}
+
+async function testPersonaDesign() {
+  console.log('\n========================================');
+  console.log('  Persona 设计测试');
+  console.log('========================================\n');
+
+  const agent = createChannelAgent({
+    name: 'TestAgent',
+    port: 8010,
+    domain: '通用'
+  });
+
+  await agent.start();
+
+  // 设计不同类型的 persona
+  const personaTypes: PersonaDesignRequest[] = [
+    { name: 'ArchMaster', type: 'developer', domain: '架构', tone: 'professional' },
+    { name: 'CodeReviewer', type: 'reviewer', domain: '安全', tone: 'formal' },
+    { name: 'TaskManager', type: 'manager', domain: '项目管理', tone: 'professional' },
+    { name: 'CreativeDesigner', type: 'designer', domain: '设计', tone: 'casual' }
+  ];
+
+  console.log('━━━ 设计 Persona ━━━\n');
+
+  for (const request of personaTypes) {
+    const persona = agent.designPersona(request);
+    console.log(`设计 ${request.type} persona:`);
+    console.log(`  名称: ${persona.name}`);
+    console.log(`  描述: ${persona.description}`);
+    console.log(`  性格: ${persona.personality}`);
+    console.log(`  能力: ${persona.capabilities.join(', ')}`);
+    console.log(`  兴趣: ${persona.interests.join(', ')}`);
+    console.log('');
+  }
+
+  // 获取当前 persona
+  const currentPersona = agent.getPersona();
+  console.log('当前 Persona:');
+  console.log(JSON.stringify(currentPersona, null, 2));
+
+  agent.shutdown();
+
+  console.log('\n========================================\n');
+}
+
+async function main() {
+  try {
+    await testMultiTurnDialogue();
+    await testPersonaDesign();
+    process.exit(0);
+  } catch (err) {
+    console.error('测试失败:', err);
+    process.exit(1);
+  }
+}
+
+main();