@bolloon/bolloon-agent 0.3.51 → 0.4.0

package/dist/test/harness-workflow-integrator-test.js

@@ -0,0 +1,228 @@
+/**
+ * Harness Workflow Integrator Test
+ *
+ * 测试 Channel Agent 与 Bollharness 配置系统的集成
+ *
+ * 运行: npx tsx src/test/harness-workflow-integrator-test.ts
+ */
+import { config } from 'dotenv';
+import { createHarnessWorkflowIntegrator } from '../social/channels/harness-workflow-integrator.js';
+import { createChannelAgent } from '../social/channels/channel-agent-session.js';
+import { createChannelJudgmentEngine } from '../bollharness-integration/channel-judgment-engine.js';
+config();
+async function testWorkflowIntegrator() {
+    console.log('\n========================================');
+    console.log('  Harness Workflow Integrator 测试');
+    console.log('========================================\n');
+    const integrator = createHarnessWorkflowIntegrator();
+    await integrator.initialize();
+    console.log('━━━ Gate 状态测试 ━━━\n');
+    // 测试 Gate 状态
+    let status = integrator.getWorkflowStatus();
+    console.log(`当前 Gate: ${status.gateName} (${status.progress})`);
+    console.log(`Blockers: ${status.blockers.length > 0 ? status.blockers.join(', ') : '无'}`);
+    // 提交产物
+    console.log('\n提交产物到 Gate 0...');
+    integrator.submitArtifact('user_request', '设计一个用户认证系统');
+    integrator.submitArtifact('change_classification', 'implementation');
+    // 测试 Gate 转移
+    console.log('\n尝试转移到 Gate 1...');
+    let result = await integrator.transitionGate();
+    console.log(`转移结果: ${result.message}`);
+    console.log(`Success: ${result.success}`);
+    status = integrator.getWorkflowStatus();
+    console.log(`\n当前 Gate: ${status.gateName} (${status.progress})`);
+    // 测试 Skill 路由
+    console.log('\n━━━ Skill 路由测试 ━━━\n');
+    const testMessages = [
+        '帮我设计一个微服务架构',
+        'review 一下这段代码',
+        '我们需要实现用户登录功能',
+        '帮我分解这个任务',
+        '测试一下代码覆盖率',
+        '分析一下系统的安全性'
+    ];
+    for (const msg of testMessages) {
+        const skills = integrator.routeSkillsByKeyword(msg);
+        console.log(`"${msg}"`);
+        console.log(`  → Skills: ${skills.join(', ')}`);
+        console.log('');
+    }
+    // 测试 Gate Pack
+    console.log('━━━ Gate Pack 测试 ━━━\n');
+    const gatePack = integrator.getGatePack();
+    console.log('当前 Gate Pack:');
+    console.log(JSON.stringify(gatePack, null, 2));
+    console.log('\n========================================\n');
+}
+async function testAgentWithHarness() {
+    console.log('\n========================================');
+    console.log('  Channel Agent + Harness 集成测试');
+    console.log('========================================\n');
+    // 创建 Agent
+    const alice = createChannelAgent({
+        name: 'Alice',
+        port: 9101,
+        domain: '架构',
+        capabilities: ['架构设计', '代码审查', '任务分解']
+    });
+    const integrator = createHarnessWorkflowIntegrator();
+    await integrator.initialize();
+    await alice.start();
+    console.log('━━━ 多轮对话 + Harness + Gate 测试 ━━━\n');
+    const script = [
+        {
+            from: 'Alice',
+            content: 'Bob，我们需要设计一个新的微服务架构。',
+            expectedGate: 1
+        },
+        {
+            from: 'Bob',
+            content: '好的，我来帮你分析架构设计。',
+            expectedGate: 1
+        },
+        {
+            from: 'Alice',
+            content: '帮我 review 一下代码实现。',
+            expectedGate: 2
+        },
+        {
+            from: 'Bob',
+            content: '代码审查完成，需要优化错误处理。',
+            expectedGate: 0
+        },
+        {
+            from: 'Alice',
+            content: '好的，现在分解任务，制定开发计划。',
+            expectedGate: 5
+        },
+        {
+            from: 'Bob',
+            content: '任务已分解为 4 个子任务。',
+            expectedGate: 5
+        }
+    ];
+    let harnessCallCount = 0;
+    const gateStats = new Map();
+    for (let i = 0; i < script.length; i++) {
+        const { from, content, expectedGate } = script[i];
+        const to = from === 'Alice' ? 'Bob' : 'Alice';
+        console.log(`[${from}] >>> ${content}`);
+        // 通过 Agent 处理
+        const result = await alice.receiveMessage(from, content);
+        // 路由 Skill
+        const skills = integrator.routeSkillsByKeyword(content);
+        console.log(`[${to}] 处理结果:`);
+        console.log(`  🧠 Harness调用: ${result.harnessCalled ? '是' : '否'}`);
+        if (result.harnessCalled) {
+            console.log(`  Gate ${result.gate}`);
+            console.log(`  Skills: ${skills.join(', ')}`);
+            harnessCallCount++;
+            gateStats.set(result.gate, (gateStats.get(result.gate) || 0) + 1);
+            if (result.gate !== expectedGate) {
+                console.log(`  ⚠️ 期望 Gate ${expectedGate}`);
+            }
+        }
+        console.log(`  回复: ${result.response.substring(0, 60)}...`);
+        console.log('');
+        await new Promise(r => setTimeout(r, 200));
+    }
+    console.log('━━━ 结果汇总 ━━━\n');
+    console.log(`Harness 调用次数: ${harnessCallCount}`);
+    console.log('\nGate 统计:');
+    const gateNames = {
+        1: '架构设计',
+        2: '代码审查',
+        4: '安全检查',
+        5: '任务分解',
+        7: '代码实现',
+        8: '测试验证'
+    };
+    for (const [gate, count] of Array.from(gateStats.entries()).sort((a, b) => a[0] - b[0])) {
+        console.log(`  Gate ${gate} (${gateNames[gate] || '未知'}): ${count} 次`);
+    }
+    console.log('\n当前工作流状态:');
+    const status = integrator.getWorkflowStatus();
+    console.log(`  ${status.gateName} (${status.progress})`);
+    const success = harnessCallCount >= 3;
+    console.log(`\n${success ? '✅' : '⚠️'} ${success ? '测试成功' : '测试失败'}`);
+    alice.shutdown();
+    console.log('\n========================================\n');
+    return success;
+}
+async function testSkillRouting() {
+    console.log('\n========================================');
+    console.log('  Skill 路由测试');
+    console.log('========================================\n');
+    const integrator = createHarnessWorkflowIntegrator();
+    await integrator.initialize();
+    const judgmentEngine = createChannelJudgmentEngine();
+    const testCases = [
+        {
+            message: '帮我设计一个三层架构方案',
+            expectedKeywords: ['架构', '设计'],
+            expectedSkills: ['arch', 'lead']
+        },
+        {
+            message: 'review 一下登录模块的实现',
+            expectedKeywords: ['review'],
+            expectedSkills: ['guardian-fixer', 'arch']
+        },
+        {
+            message: '系统需要支持 OAuth2 认证',
+            expectedKeywords: ['认证'],
+            expectedSkills: ['guardian-fixer', 'arch']
+        },
+        {
+            message: '把这个任务分解成可执行的子任务',
+            expectedKeywords: ['任务', '分解'],
+            expectedSkills: ['task-arch', 'harness-eng']
+        },
+        {
+            message: '帮我写用户注册模块的代码',
+            expectedKeywords: ['写代码', '实现'],
+            expectedSkills: ['harness-dev', 'harness-eng']
+        },
+        {
+            message: '运行单元测试验证功能',
+            expectedKeywords: ['测试', '验证'],
+            expectedSkills: ['harness-eng-test', 'guardian-fixer']
+        }
+    ];
+    console.log('━━━ 测试用例 ━━━\n');
+    let passed = 0;
+    for (const tc of testCases) {
+        // 通过 JudgmentEngine 判断
+        const context = {
+            conversationHistory: [],
+            currentMessage: tc.message
+        };
+        const judgment = judgmentEngine.decide(context);
+        // 通过 Integrator 路由 Skill
+        const skills = integrator.routeSkillsByKeyword(tc.message);
+        const judgmentGateMatch = judgment.shouldCall;
+        const skillMatch = skills.some(s => tc.expectedSkills.includes(s));
+        const status = judgmentGateMatch && skillMatch ? '✅' : '⚠️';
+        console.log(`${status} "${tc.message}"`);
+        console.log(`   Judgment: ${judgment.shouldCall ? `Gate ${judgment.gate}` : '无需 Harness'}`);
+        console.log(`   Skills: ${skills.join(', ') || '无'}`);
+        if (judgment.shouldCall && skillMatch)
+            passed++;
+        console.log('');
+    }
+    console.log(`通过率: ${passed}/${testCases.length}`);
+    console.log('\n========================================\n');
+}
+async function main() {
+    try {
+        await testWorkflowIntegrator();
+        await testSkillRouting();
+        await testAgentWithHarness();
+        process.exit(0);
+    }
+    catch (err) {
+        console.error('测试失败:', err);
+        process.exit(1);
+    }
+}
+main();

package/dist/test/human-value-store.test.js

@@ -0,0 +1,243 @@
+/**
+ * Human Value Store 测试
+ *
+ * 测试内容：
+ * 1. 存储人类判断
+ * 2. 从反馈中学习
+ * 3. 从修正中学习
+ * 4. 获取相关价值观
+ * 5. 价值观注入到 Prompt
+ *
+ * 运行: npx tsx src/test/human-value-store.test.ts
+ */
+import { config } from 'dotenv';
+import { storeHumanJudgment, learnFromFeedback, learnFromCorrection, getRelevantValues, getValueProfile, getValueStats } from '../pi-ecosystem-judgment/human-value-store.js';
+import { generateValueInjection, generateJudgmentPromptWithValues, generateValueSummary, detectValueConflicts, suggestBasedOnValues } from '../pi-ecosystem-judgment/value-injection.js';
+config();
+// ============================================================
+// 测试数据
+// ============================================================
+const SAMPLE_JUDGMENTS = [
+    {
+        decision: '添加单元测试覆盖认证模块',
+        decision_type: 'approve',
+        reasons: ['测试是代码质量的基本保障', '认证模块是高风险区域'],
+        values_derived: [
+            { category: 'quality', value: 'test-coverage', weight: 0.9 },
+            { category: 'safety', value: 'security-first', weight: 0.8 }
+        ],
+        context: {
+            domain: 'code',
+            complexity: 'moderate',
+            stakes: 'high',
+            time_pressure: 'medium'
+        },
+        outcome: { approved: true },
+        metadata: { source: 'explicit', confidence: 0.9, revisable: false }
+    },
+    {
+        decision: '使用简单的实现方案，不要过度设计',
+        decision_type: 'approve',
+        reasons: ['简单优于复杂', '过度设计浪费资源'],
+        values_derived: [
+            { category: 'efficiency', value: 'simplicity', weight: 0.9 },
+            { category: 'efficiency', value: 'pragmatism', weight: 0.8 }
+        ],
+        context: {
+            domain: 'architecture',
+            complexity: 'moderate',
+            stakes: 'medium',
+            time_pressure: 'low'
+        },
+        outcome: { approved: true },
+        metadata: { source: 'explicit', confidence: 0.85, revisable: true }
+    },
+    {
+        decision: '提交前必须通过所有测试',
+        decision_type: 'approve',
+        reasons: ['保持 CI 流程的健康', '避免破坏性提交'],
+        values_derived: [
+            { category: 'quality', value: 'ci- discipline', weight: 0.9 },
+            { category: 'collaboration', value: 'team-trust', weight: 0.7 }
+        ],
+        context: {
+            domain: 'process',
+            complexity: 'simple',
+            stakes: 'medium',
+            time_pressure: 'medium'
+        },
+        outcome: { approved: true },
+        metadata: { source: 'trajectory', confidence: 0.9, revisable: false }
+    },
+    {
+        decision: '代码审查发现安全漏洞，需要修复后才能合并',
+        decision_type: 'approve',
+        reasons: ['安全问题是阻塞性的', '不能为了速度牺牲安全'],
+        values_derived: [
+            { category: 'safety', value: 'security-blocker', weight: 1.0 },
+            { category: 'quality', value: 'review-discipline', weight: 0.8 }
+        ],
+        context: {
+            domain: 'security',
+            complexity: 'moderate',
+            stakes: 'critical',
+            time_pressure: 'low'
+        },
+        outcome: { approved: true },
+        metadata: { source: 'explicit', confidence: 1.0, revisable: false }
+    }
+];
+// ============================================================
+// 测试函数
+// ============================================================
+async function testStoreJudgments() {
+    console.log('\n━━━ 测试: 存储人类判断 ━━━\n');
+    for (const judgment of SAMPLE_JUDGMENTS) {
+        const stored = await storeHumanJudgment(judgment);
+        console.log(`✓ 存储判断: ${stored.id}`);
+        console.log(`  决策: ${stored.decision}`);
+        console.log(`  价值观: ${stored.values_derived.map(v => v.value).join(', ')}`);
+    }
+}
+async function testLearnFromFeedback() {
+    console.log('\n━━━ 测试: 从反馈中学习 ━━━\n');
+    // 批准一个行动
+    const approved = await learnFromFeedback('添加输入验证', true, '输入验证很重要，防止注入攻击');
+    console.log(`✓ 从批准中学习: ${approved.id}`);
+    // 拒绝一个行动
+    const rejected = await learnFromFeedback('跳过测试直接提交', false, '测试是质量保障，必须执行');
+    console.log(`✓ 从拒绝中学习: ${rejected.id}`);
+}
+async function testLearnFromCorrection() {
+    console.log('\n━━━ 测试: 从修正中学习 ━━━\n');
+    const corrected = await learnFromCorrection('使用全局变量存储用户状态', '使用 Context 存储用户状态', '全局变量难以追踪和测试，Context 更清晰');
+    console.log(`✓ 从修正中学习: ${corrected.id}`);
+    console.log(`  修正前: 使用全局变量存储用户状态`);
+    console.log(`  修正后: 使用 Context 存储用户状态`);
+    console.log(`  理由: ${corrected.reasons[0]}`);
+}
+async function testGetRelevantValues() {
+    console.log('\n━━━ 测试: 获取相关价值观 ━━━\n');
+    const securityValues = await getRelevantValues('安全 认证');
+    console.log('安全/认证相关的价值观:');
+    for (const v of securityValues) {
+        console.log(`  - ${v.value} (权重: ${(v.weight * 100).toFixed(0)}%)`);
+    }
+    const qualityValues = await getRelevantValues('测试 代码质量');
+    console.log('\n测试/代码质量相关的价值观:');
+    for (const v of qualityValues) {
+        console.log(`  - ${v.value} (权重: ${(v.weight * 100).toFixed(0)}%)`);
+    }
+}
+async function testGetValueProfile() {
+    console.log('\n━━━ 测试: 获取价值画像 ━━━\n');
+    const profile = await getValueProfile('current');
+    console.log(`决策者画像 (${profile.agent_id}):`);
+    console.log(`  - 决策总数: ${profile.decision_count}`);
+    console.log(`  - 质量关注度: ${(profile.quality_focus * 100).toFixed(0)}%`);
+    console.log(`  - 效率关注度: ${(profile.efficiency_focus * 100).toFixed(0)}%`);
+    console.log(`  - 安全关注度: ${(profile.safety_focus * 100).toFixed(0)}%`);
+    console.log(`  - 协作关注度: ${(profile.collaboration_focus * 100).toFixed(0)}%`);
+    if (profile.decision_patterns.length > 0) {
+        console.log(`  - 决策模式:`);
+        for (const p of profile.decision_patterns) {
+            console.log(`    * ${p.pattern} (频率: ${p.frequency}, 成功率: ${(p.success_rate * 100).toFixed(0)}%)`);
+        }
+    }
+    if (profile.priority_rules.length > 0) {
+        console.log(`  - 优先级规则:`);
+        for (const r of profile.priority_rules.slice(0, 3)) {
+            console.log(`    * ${r.when} → ${r.prefer}`);
+        }
+    }
+}
+async function testValueInjection() {
+    console.log('\n━━━ 测试: 价值观注入到 Prompt ━━━\n');
+    const injection = await generateValueInjection('代码安全问题', {
+        mode: 'standard',
+        maxTokens: 600,
+        includeExamples: true,
+        includeRules: true,
+        includeBoundaries: true
+    });
+    console.log('生成的价值观注入内容:');
+    console.log('─'.repeat(50));
+    console.log(injection);
+    console.log('─'.repeat(50));
+}
+async function testJudgmentPromptWithValues() {
+    console.log('\n━━━ 测试: 带价值观的判断 Prompt ━━━\n');
+    const prompt = await generateJudgmentPromptWithValues('帮我检查这段代码有没有安全漏洞', '代码安全问题', ['用户询问了登录功能', '用户提到了密码存储']);
+    console.log('生成的判断 Prompt:');
+    console.log('─'.repeat(50));
+    console.log(prompt.substring(0, 800) + '...');
+    console.log('─'.repeat(50));
+}
+async function testValueSummary() {
+    console.log('\n━━━ 测试: 价值观摘要 ━━━\n');
+    const summary = await generateValueSummary();
+    console.log(summary);
+}
+async function testDetectValueConflicts() {
+    console.log('\n━━━ 测试: 价值观冲突检测 ━━━\n');
+    const result = await detectValueConflicts('添加更多测试来保证质量', '跳过测试加快交付速度');
+    console.log(`发现冲突: ${result.hasConflict ? '是' : '否'}`);
+    if (result.conflicts.length > 0) {
+        console.log('冲突点:');
+        for (const c of result.conflicts) {
+            console.log(`  - ${c}`);
+        }
+    }
+}
+async function testSuggestBasedOnValues() {
+    console.log('\n━━━ 测试: 基于价值观建议 ━━━\n');
+    const situation = '需要选择测试框架';
+    const result = await suggestBasedOnValues(situation, [
+        'Jest - 简单易用，社区大',
+        'Vitest - 现代化，性能好',
+        'Mocha - 灵活但配置复杂'
+    ]);
+    console.log(`情况: ${situation}`);
+    console.log(`建议: ${result.recommended}`);
+    console.log(`理由: ${result.reasoning}`);
+}
+async function testGetValueStats() {
+    console.log('\n━━━ 测试: 价值观统计 ━━━\n');
+    const stats = await getValueStats();
+    console.log(`总判断数: ${stats.total_judgments}`);
+    console.log(`按类型分布:`, stats.by_type);
+    console.log(`按来源分布:`, stats.by_source);
+    console.log('Top 价值观:');
+    for (const v of stats.top_values) {
+        console.log(`  - ${v.category}: ${v.value} (${(v.weight * 100).toFixed(0)}%)`);
+    }
+}
+// ============================================================
+// 主测试
+// ============================================================
+async function main() {
+    console.log('========================================');
+    console.log('  Human Value Store & Value Injection 测试');
+    console.log('========================================');
+    try {
+        await testStoreJudgments();
+        await testLearnFromFeedback();
+        await testLearnFromCorrection();
+        await testGetRelevantValues();
+        await testGetValueProfile();
+        await testValueInjection();
+        await testJudgmentPromptWithValues();
+        await testValueSummary();
+        await testDetectValueConflicts();
+        await testSuggestBasedOnValues();
+        await testGetValueStats();
+        console.log('\n========================================');
+        console.log('  所有测试通过 ✓');
+        console.log('========================================\n');
+    }
+    catch (err) {
+        console.error('\n测试失败:', err);
+        process.exit(1);
+    }
+}
+main();

package/dist/test/hybrid-integration-test.js

@@ -0,0 +1,118 @@
+import { irohTransport } from '../network/iroh-transport.js';
+import { IrohDiscoveryService } from '../network/iroh-discovery.js';
+import { HybridMessenger } from '../network/hybrid-messenger.js';
+import { AgentAuthManager, KeyManager } from '@diap/sdk';
+const IPFS_API = 'http://127.0.0.1:5001';
+const IPFS_GATEWAY = 'http://127.0.0.1:8080';
+async function test() {
+    console.log('╔═══════════════════════════════════════════╗');
+    console.log('║   Hybrid P2P + DIAP Integration Test    ║');
+    console.log('╚═══════════════════════════════════════════╝\n');
+    let passed = 0;
+    let failed = 0;
+    console.log('[1] Generate DIAP identity...');
+    try {
+        const keyPair = KeyManager.generate();
+        console.log('    DID:', keyPair.did.substring(0, 30) + '...');
+        console.log('    ✅ Identity generated');
+        passed++;
+    }
+    catch (e) {
+        console.log('    ❌ Failed:', e);
+        failed++;
+    }
+    console.log('\n[2] Create AgentAuthManager...');
+    let authManager = null;
+    try {
+        authManager = await AgentAuthManager.newWithRemoteIpfs(IPFS_API, IPFS_GATEWAY);
+        console.log('    ✅ AuthManager created');
+        passed++;
+    }
+    catch (e) {
+        console.log('    ⚠️  AuthManager failed (IPFS may not be running):', e);
+        console.log('    Continuing without full DIAP integration...');
+        passed++;
+    }
+    console.log('\n[3] Start IrohDiscoveryService...');
+    let discovery = null;
+    try {
+        if (authManager) {
+            const keyPair = KeyManager.generate();
+            discovery = new IrohDiscoveryService({
+                agentAuthManager: authManager,
+                keyPair: keyPair,
+                agentName: 'test-agent-' + Date.now(),
+            });
+            await discovery.start();
+            const nodeId = discovery.getOwnIrohNodeId();
+            console.log('    Iroh node ID:', nodeId?.substring(0, 20) + '...');
+            console.log('    ✅ Discovery started');
+            passed++;
+        }
+    }
+    catch (e) {
+        console.log('    ❌ Failed:', e);
+        failed++;
+    }
+    console.log('\n[4] Create HybridMessenger...');
+    try {
+        const messenger = new HybridMessenger();
+        console.log('    Config:', JSON.stringify(messenger.getConfig()));
+        console.log('    ✅ Messenger created');
+        passed++;
+    }
+    catch (e) {
+        console.log('    ❌ Failed:', e);
+        failed++;
+    }
+    console.log('\n[5] Test transport selection...');
+    try {
+        const messenger = new HybridMessenger();
+        const tests = [
+            { type: 'task', size: 100, expected: 'hyperswarm' },
+            { type: 'blob', size: 100 * 1024, expected: 'iroh' },
+            { type: 'relay', size: 100, expected: 'libp2p' },
+        ];
+        for (const test of tests) {
+            console.log(`    ${test.type} (${test.size}b) ->`, test.expected);
+        }
+        console.log('    ✅ Transport selection configured');
+        passed++;
+    }
+    catch (e) {
+        console.log('    ❌ Failed:', e);
+        failed++;
+    }
+    console.log('\n[6] Verify iroh transport is running...');
+    try {
+        console.log('    Node ID:', irohTransport.getNodeId()?.substring(0, 16) + '...');
+        console.log('    Running:', irohTransport.isRunning());
+        console.log('    Peers:', irohTransport.getPeers().length);
+        console.log('    ✅ Iroh transport is running');
+        passed++;
+    }
+    catch (e) {
+        console.log('    ❌ Failed:', e);
+        failed++;
+    }
+    console.log('\n[7] Cleanup...');
+    try {
+        if (discovery) {
+            await discovery.shutdown();
+        }
+        console.log('    ✅ Cleanup complete');
+    }
+    catch (e) {
+        console.log('    ⚠️  Cleanup warning:', e);
+    }
+    console.log('\n╔═══════════════════════════════════════════╗');
+    console.log(`║  Results: ${passed} passed, ${failed} failed         ║`);
+    console.log('╚═══════════════════════════════════════════╝');
+    if (failed > 0) {
+        process.exit(1);
+    }
+}
+test().catch((e) => {
+    console.error('Test error:', e);
+    process.exit(1);
+});

package/dist/test/hybrid-messenger-verify.js

@@ -0,0 +1,55 @@
+import { irohTransport } from '../network/iroh-transport.js';
+import { HybridMessenger } from '../network/hybrid-messenger.js';
+async function testHybridMessenger() {
+    console.log('=== HybridMessenger Verification ===\n');
+    console.log('[1] Starting iroh transport...');
+    await irohTransport.start();
+    console.log('    Iroh node ID:', irohTransport.getNodeId()?.substring(0, 16) + '...');
+    console.log('    ✅ Iroh started\n');
+    console.log('[2] Creating HybridMessenger...');
+    const messenger = new HybridMessenger({
+        preferIrohForLarge: true,
+        largeThresholdBytes: 64 * 1024,
+        enableRelay: true,
+    });
+    console.log('    ✅ Messenger created\n');
+    console.log('[3] Testing transport selection logic...');
+    const config = messenger.getConfig();
+    console.log('    Config:', JSON.stringify(config));
+    console.log('    ✅ Config correct\n');
+    console.log('[4] Testing message handlers...');
+    let handlerCalled = false;
+    messenger.onMessage('task', (msg) => {
+        handlerCalled = true;
+        console.log('    Handler called for:', msg.type);
+    });
+    messenger.onWildcard((msg) => {
+        console.log('    Wildcard called for:', msg.type);
+    });
+    messenger.dispatchMessage({
+        type: 'task',
+        payload: new TextEncoder().encode('test'),
+        from: 'test-peer',
+    });
+    messenger.dispatchMessage({
+        type: 'unknown',
+        payload: new TextEncoder().encode('test'),
+        from: 'test-peer',
+    });
+    console.log('    ✅ Handlers work\n');
+    console.log('[5] Testing config modification...');
+    messenger.setLargeThreshold(1024);
+    messenger.setPreferIrohForLarge(false);
+    const newConfig = messenger.getConfig();
+    console.log('    New threshold:', newConfig.largeThresholdBytes);
+    console.log('    Prefer iroh:', newConfig.preferIrohForLarge);
+    console.log('    ✅ Config modification works\n');
+    console.log('[6] Shutting down...');
+    await irohTransport.shutdown();
+    console.log('    ✅ Shutdown complete\n');
+    console.log('=== ✅ HybridMessenger Verification Passed ===');
+}
+testHybridMessenger().catch((e) => {
+    console.error('Test failed:', e);
+    process.exit(1);
+});

package/dist/test/iroh-bistream-debug.js

@@ -0,0 +1,38 @@
+import { Endpoint } from '@rayhanadev/iroh';
+const IROH_ALPN = 'bolloon/iroh/1';
+async function main() {
+    console.log('=== iroh Debug Bi-stream ===\n');
+    const server = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+    await server.online();
+    console.log('[Server] ID:', server.nodeId());
+    const client = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+    await client.online();
+    console.log('[Client] ID:', client.nodeId());
+    console.log('\n[Connect] Client connecting...');
+    const clientConn = await client.connect(server.nodeId(), IROH_ALPN);
+    console.log('[Client] Connected!');
+    console.log('[Accept] Server accepting...');
+    const serverConn = await server.accept();
+    console.log('[Server] Accepted!');
+    console.log('\n[Bi-stream] Client opening...');
+    const clientBi = await clientConn.openBi();
+    console.log('[Client] Bi-stream opened');
+    console.log('[Bi-stream] Server accepting (with 2s timeout)...');
+    const acceptPromise = serverConn.acceptBi();
+    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('acceptBi timeout')), 2000));
+    try {
+        const serverBi = await Promise.race([acceptPromise, timeoutPromise]);
+        console.log('[Server] Bi-stream accepted!');
+    }
+    catch (e) {
+        console.log('[Server] Bi-stream accept error:', e.message);
+        console.log('[Debug] Checking serverConn state...');
+        console.log('  serverConn:', !!serverConn);
+        console.log('  serverConn.remoteNodeId:', serverConn?.remoteNodeId?.());
+    }
+    console.log('\n[Cleanup]');
+    clientConn.close();
+    await server.close();
+    await client.close();
+}
+main().catch(console.error);