@toyako/hive 1.0.0

package/dist/commands/test-v2-integration.js

@@ -0,0 +1,634 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Test: V2.0 Integration — Phase B Features
+ *
+ * Verifies:
+ * 1. Multi-agent graph task (Planner→Executor→Reviewer)
+ * 2. Escalation policy: executor fails → escalate to senior reviewer
+ * 3. Multi-reviewer consensus: 2 reviewers majority voting
+ * 4. Safety layer: hop limit + message dedup + circuit breaker
+ * 5. v1.1 backward compatibility: old format task runs normally
+ */
+const Broker_1 = require("../broker/Broker");
+const ReviewConsensus_1 = require("../review/ReviewConsensus");
+const CircuitBreaker_1 = require("../safety/CircuitBreaker");
+const HopCounter_1 = require("../safety/HopCounter");
+const MessageDeduplicator_1 = require("../safety/MessageDeduplicator");
+const fs = __importStar(require("fs"));
+function cleanupBrokerState() {
+    try {
+        fs.rmSync(".agent-hive", { recursive: true, force: true });
+    }
+    catch { }
+}
+// ─── Mock Adapters ────────────────────────────────────
+class MockPlanner {
+    name = "planner";
+    role = "planner";
+    capabilities = ["planning"];
+    async detect() { return true; }
+    async health() { return true; }
+    async execute(task) {
+        await this.sleep(50);
+        return { success: true, output: `[Planner] Plan: \"${task.instruction}\" → 3 steps` };
+    }
+    sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+}
+class MockExecutor {
+    name = "executor";
+    role = "developer";
+    capabilities = ["coding"];
+    async detect() { return true; }
+    async health() { return true; }
+    async execute(task, instruction) {
+        await this.sleep(100);
+        return { success: true, output: `[Executor] Completed: \"${instruction || task.instruction}\"` };
+    }
+    sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+}
+class FailExecutor {
+    name = "fail-executor";
+    role = "developer";
+    capabilities = ["coding"];
+    async detect() { return true; }
+    async health() { return true; }
+    async execute(task, instruction) {
+        await this.sleep(50);
+        return { success: true, output: `[FailExecutor] Buggy output for: \"${instruction || task.instruction}\"` };
+    }
+    sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+}
+class SeniorExecutor {
+    name = "senior-executor";
+    role = "developer";
+    capabilities = ["coding", "review"];
+    async detect() { return true; }
+    async health() { return true; }
+    async execute(task, instruction) {
+        await this.sleep(100);
+        return { success: true, output: `[SeniorExecutor] High quality: \"${instruction || task.instruction}\"` };
+    }
+    async review(task) {
+        await this.sleep(50);
+        return { decision: "PASS", score: 95, issues: [] };
+    }
+    sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+}
+class MockReviewer {
+    name = "reviewer";
+    role = "reviewer";
+    capabilities = ["review"];
+    failCount;
+    callCount = 0;
+    constructor(opts) { this.failCount = opts?.failCount ?? 0; }
+    async detect() { return true; }
+    async health() { return true; }
+    async execute() { return { success: true, output: "" }; }
+    async review(task) {
+        await this.sleep(50);
+        this.callCount++;
+        if (this.callCount <= this.failCount) {
+            return { decision: "FAIL", score: 40, issues: ["Mock issue: needs improvement"] };
+        }
+        return { decision: "PASS", score: 90, issues: [] };
+    }
+    getCallCount() { return this.callCount; }
+    reset() { this.callCount = 0; }
+    sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+}
+class StrictReviewer {
+    name = "strict-reviewer";
+    role = "reviewer";
+    capabilities = ["review"];
+    callCount = 0;
+    failUntilCall;
+    constructor(opts) { this.failUntilCall = opts?.failUntilCall ?? Infinity; }
+    async detect() { return true; }
+    async health() { return true; }
+    async execute() { return { success: true, output: "" }; }
+    async review(task) {
+        this.callCount++;
+        if (this.callCount <= this.failUntilCall) {
+            return {
+                decision: "FAIL",
+                score: 20,
+                issues: ["Critical: missing error handling", "Major: no unit tests"],
+            };
+        }
+        return { decision: "PASS", score: 90, issues: [] };
+    }
+    getCallCount() { return this.callCount; }
+    reset() { this.callCount = 0; }
+    sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+}
+class LenientReviewer {
+    name = "lenient-reviewer";
+    role = "reviewer";
+    capabilities = ["review"];
+    callCount = 0;
+    async detect() { return true; }
+    async health() { return true; }
+    async execute() { return { success: true, output: "" }; }
+    async review(task) {
+        this.callCount++;
+        return {
+            decision: "PASS",
+            score: 75,
+            issues: ["Minor: could add more comments"],
+        };
+    }
+    getCallCount() { return this.callCount; }
+    sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+}
+// ─── Test 1: Multi-agent graph task ───────────────────
+async function test1_MultiAgentGraphTask() {
+    console.log("\n  [Test 1] Multi-Agent Graph Task (Planner→Executor→Reviewer)");
+    console.log("  ─────────────────────────────────────────────────────────────");
+    cleanupBrokerState();
+    const broker = new Broker_1.Broker();
+    let pass = true;
+    // Register adapters
+    await broker.registerAdapter(new MockPlanner());
+    await broker.registerAdapter(new MockExecutor());
+    await broker.registerAdapter(new MockReviewer());
+    // Set up graph: planner → executor → reviewer
+    broker.addAgentProfile({ id: "planner", runtimeId: "planner", role: "planner", maxConcurrency: 1, status: "idle" });
+    broker.addAgentProfile({ id: "executor", runtimeId: "executor", role: "executor", maxConcurrency: 1, status: "idle" });
+    broker.addAgentProfile({ id: "reviewer", runtimeId: "reviewer", role: "reviewer", maxConcurrency: 1, status: "idle" });
+    broker.addGraphEdge("planner", "executor", "delegates", 10);
+    broker.addGraphEdge("executor", "reviewer", "reviews", 10);
+    broker.enableGraphMode();
+    // Submit task
+    broker.submit({
+        instruction: "Create a REST API with Express",
+        executor: "executor",
+        reviewer: "reviewer",
+    });
+    await broker.run();
+    const tasks = broker.listTasks();
+    if (tasks.length !== 1) {
+        console.log(`    ✗ Task count: ${tasks.length}`);
+        pass = false;
+    }
+    else if (tasks[0].status !== "COMPLETED") {
+        console.log(`    ✗ Task status: ${tasks[0].status}`);
+        pass = false;
+    }
+    else
+        console.log("    ✓ Task completed via multi-agent graph");
+    // Verify graph has all agents
+    const graph = broker.getGraph();
+    if (graph.allAgents().length < 3) {
+        console.log(`    ✗ Graph agents: ${graph.allAgents().length}`);
+        pass = false;
+    }
+    else
+        console.log("    ✓ Graph has 3+ agents");
+    console.log(`\n  Test 1: ${pass ? "PASS ✓" : "FAIL ✗"}`);
+    return pass;
+}
+// ─── Test 2: Escalation policy — escalate ─────────────
+async function test2_EscalationPolicy() {
+    console.log("\n  [Test 2] Escalation Policy: executor fails → escalate to senior");
+    console.log("  ─────────────────────────────────────────────────────────────");
+    cleanupBrokerState();
+    const broker = new Broker_1.Broker();
+    let pass = true;
+    // Register adapters
+    await broker.registerAdapter(new FailExecutor());
+    await broker.registerAdapter(new SeniorExecutor());
+    await broker.registerAdapter(new StrictReviewer({ failUntilCall: 3 }));
+    // Set up graph
+    broker.addAgentProfile({ id: "fail-executor", runtimeId: "fail-executor", role: "executor", maxConcurrency: 1, status: "idle" });
+    broker.addAgentProfile({ id: "senior-executor", runtimeId: "senior-executor", role: "executor", maxConcurrency: 1, status: "idle" });
+    broker.addAgentProfile({ id: "strict-reviewer", runtimeId: "strict-reviewer", role: "reviewer", maxConcurrency: 1, status: "idle" });
+    broker.addGraphEdge("fail-executor", "strict-reviewer", "reviews", 10);
+    broker.addGraphEdge("senior-executor", "strict-reviewer", "reviews", 10);
+    broker.enableGraphMode();
+    // Submit with escalation policy
+    broker.submit({
+        instruction: "Create a secure authentication module",
+        executor: "fail-executor",
+        reviewer: "strict-reviewer",
+        maxRevision: 2,
+        escalationPolicy: {
+            onMaxRevisionReached: "escalate",
+            escalateTo: "senior-executor",
+        },
+    });
+    await broker.run();
+    const tasks = broker.listTasks();
+    if (tasks.length !== 1) {
+        console.log(`    ✗ Task count: ${tasks.length}`);
+        pass = false;
+    }
+    else if (tasks[0].status !== "COMPLETED") {
+        console.log(`    ✗ Task status: ${tasks[0].status} (expected COMPLETED)`);
+        pass = false;
+    }
+    else
+        console.log("    ✓ Task completed after escalation");
+    // Verify the task executor was changed to senior-executor
+    if (tasks[0].executor !== "senior-executor") {
+        console.log(`    ✗ Executor not changed: ${tasks[0].executor}`);
+        pass = false;
+    }
+    else {
+        console.log("    ✓ Executor changed to senior-executor");
+    }
+    // Verify revision count was reset (should be 0 since senior-executor passed on first try)
+    if (tasks[0].revisionCount !== 0) {
+        console.log(`    ✗ Revision count not reset: ${tasks[0].revisionCount}`);
+        pass = false;
+    }
+    else {
+        console.log("    ✓ Revision count reset to 0 after escalation");
+    }
+    console.log(`\n  Test 2: ${pass ? "PASS ✓" : "FAIL ✗"}`);
+    return pass;
+}
+// ─── Test 3: Multi-reviewer consensus ─────────────────
+async function test3_MultiReviewerConsensus() {
+    console.log("\n  [Test 3] Multi-Reviewer Consensus (majority voting)");
+    console.log("  ─────────────────────────────────────────────────────");
+    let pass = true;
+    // Scenario A: Majority — 2 PASS, 1 FAIL → PASS
+    console.log("\n    [3a] Majority: 2 PASS + 1 FAIL → PASS");
+    const consensusA = new ReviewConsensus_1.ReviewConsensus({
+        minReviewers: 2,
+        consensusStrategy: "majority",
+        onDisagreement: "highest-score",
+    });
+    const votesA = [
+        { reviewerId: "reviewer-1", result: { decision: "PASS", score: 85, issues: [] }, timestamp: Date.now() },
+        { reviewerId: "reviewer-2", result: { decision: "PASS", score: 80, issues: ["minor style issue"] }, timestamp: Date.now() },
+        { reviewerId: "reviewer-3", result: { decision: "FAIL", score: 50, issues: ["missing tests"] }, timestamp: Date.now() },
+    ];
+    const resultA = consensusA.resolve(votesA);
+    if (resultA.finalDecision !== "PASS") {
+        console.log(`      ✗ Expected PASS, got ${resultA.finalDecision}`);
+        pass = false;
+    }
+    else {
+        console.log(`      ✓ Majority PASS (${resultA.strategy})`);
+    }
+    // Scenario B: Majority — 1 PASS, 2 FAIL → FAIL
+    console.log("\n    [3b] Majority: 1 PASS + 2 FAIL → FAIL");
+    const consensusB = new ReviewConsensus_1.ReviewConsensus({
+        minReviewers: 2,
+        consensusStrategy: "majority",
+        onDisagreement: "highest-score",
+    });
+    const votesB = [
+        { reviewerId: "reviewer-1", result: { decision: "PASS", score: 70, issues: [] }, timestamp: Date.now() },
+        { reviewerId: "reviewer-2", result: { decision: "FAIL", score: 40, issues: ["critical bug"] }, timestamp: Date.now() },
+        { reviewerId: "reviewer-3", result: { decision: "FAIL", score: 30, issues: ["security hole"] }, timestamp: Date.now() },
+    ];
+    const resultB = consensusB.resolve(votesB);
+    if (resultB.finalDecision !== "FAIL") {
+        console.log(`      ✗ Expected FAIL, got ${resultB.finalDecision}`);
+        pass = false;
+    }
+    else {
+        console.log(`      ✓ Majority FAIL (${resultB.strategy})`);
+    }
+    // Scenario C: Unanimous — all PASS → PASS
+    console.log("\n    [3c] Unanimous: all PASS → PASS");
+    const consensusC = new ReviewConsensus_1.ReviewConsensus({
+        minReviewers: 2,
+        consensusStrategy: "unanimous",
+        onDisagreement: "highest-score",
+    });
+    const votesC = [
+        { reviewerId: "reviewer-1", result: { decision: "PASS", score: 90, issues: [] }, timestamp: Date.now() },
+        { reviewerId: "reviewer-2", result: { decision: "PASS", score: 85, issues: [] }, timestamp: Date.now() },
+    ];
+    const resultC = consensusC.resolve(votesC);
+    if (resultC.finalDecision !== "PASS") {
+        console.log(`      ✗ Expected PASS, got ${resultC.finalDecision}`);
+        pass = false;
+    }
+    else {
+        console.log(`      ✓ Unanimous PASS`);
+    }
+    // Scenario D: Unanimous — mixed → FAIL
+    console.log("\n    [3d] Unanimous: mixed votes → FAIL");
+    const votesD = [
+        { reviewerId: "reviewer-1", result: { decision: "PASS", score: 90, issues: [] }, timestamp: Date.now() },
+        { reviewerId: "reviewer-2", result: { decision: "FAIL", score: 40, issues: ["issue"] }, timestamp: Date.now() },
+    ];
+    const resultD = consensusC.resolve(votesD);
+    if (resultD.finalDecision !== "FAIL") {
+        console.log(`      ✗ Expected FAIL, got ${resultD.finalDecision}`);
+        pass = false;
+    }
+    else {
+        console.log(`      ✓ Unanimous FAIL (mixed votes)`);
+    }
+    // Scenario E: Best-score — highest score 80 → PASS
+    console.log("\n    [3e] Best-score: highest 80 → PASS");
+    const consensusE = new ReviewConsensus_1.ReviewConsensus({
+        minReviewers: 1,
+        consensusStrategy: "best-score",
+        onDisagreement: "highest-score",
+    });
+    const votesE = [
+        { reviewerId: "reviewer-1", result: { decision: "FAIL", score: 40, issues: ["bug"] }, timestamp: Date.now() },
+        { reviewerId: "reviewer-2", result: { decision: "PASS", score: 80, issues: [] }, timestamp: Date.now() },
+    ];
+    const resultE = consensusE.resolve(votesE);
+    if (resultE.finalDecision !== "PASS") {
+        console.log(`      ✗ Expected PASS, got ${resultE.finalDecision}`);
+        pass = false;
+    }
+    else {
+        console.log(`      ✓ Best-score PASS (score: ${resultE.score})`);
+    }
+    // Scenario F: Disagreement resolution via highest-score
+    console.log("\n    [3f] Disagreement: 1 PASS + 1 FAIL, highest-score resolution");
+    const consensusF = new ReviewConsensus_1.ReviewConsensus({
+        minReviewers: 2,
+        consensusStrategy: "majority",
+        onDisagreement: "highest-score",
+    });
+    const votesF = [
+        { reviewerId: "reviewer-1", result: { decision: "PASS", score: 75, issues: [] }, timestamp: Date.now() },
+        { reviewerId: "reviewer-2", result: { decision: "FAIL", score: 50, issues: ["issue"] }, timestamp: Date.now() },
+    ];
+    const resultF = consensusF.resolve(votesF);
+    if (resultF.finalDecision !== "PASS") {
+        console.log(`      ✗ Expected PASS (higher score), got ${resultF.finalDecision}`);
+        pass = false;
+    }
+    else {
+        console.log(`      ✓ Disagreement resolved via highest-score: PASS`);
+    }
+    // Scenario G: Disagreement via escalate
+    console.log("\n    [3g] Disagreement: escalate resolution");
+    const consensusG = new ReviewConsensus_1.ReviewConsensus({
+        minReviewers: 2,
+        consensusStrategy: "majority",
+        onDisagreement: "escalate",
+    });
+    const votesG = [
+        { reviewerId: "reviewer-1", result: { decision: "PASS", score: 70, issues: [] }, timestamp: Date.now() },
+        { reviewerId: "reviewer-2", result: { decision: "FAIL", score: 65, issues: ["issue"] }, timestamp: Date.now() },
+    ];
+    const resultG = consensusG.resolve(votesG);
+    if (!resultG.resolution?.includes("escalated")) {
+        console.log(`      ✗ Expected escalation resolution, got: ${resultG.resolution}`);
+        pass = false;
+    }
+    else {
+        console.log(`      ✓ Disagreement escalated (resolved via highest-score fallback)`);
+    }
+    console.log(`\n  Test 3: ${pass ? "PASS ✓" : "FAIL ✗"}`);
+    return pass;
+}
+// ─── Test 4: Safety layer integration ─────────────────
+async function test4_SafetyLayerIntegration() {
+    console.log("\n  [Test 4] Safety Layer Integration");
+    console.log("  ─────────────────────────────────────────────────────");
+    let pass = true;
+    // 4a: HopCounter
+    console.log("\n    [4a] HopCounter: message hop limit");
+    const hc = new HopCounter_1.HopCounter(3);
+    const msg = {
+        id: "test-msg-1",
+        taskId: "task-1",
+        conversationId: "conv-1",
+        from: "agent-a",
+        to: "agent-b",
+        type: "TASK",
+        payload: {},
+        metadata: { hopCount: 0, maxHops: 3, priority: 5, routingPath: ["agent-a"] },
+        timestamp: Date.now(),
+    };
+    if (hc.isExceeded(msg)) {
+        console.log("      ✗ Should not be exceeded at hop 0");
+        pass = false;
+    }
+    else
+        console.log("      ✓ Not exceeded at hop 0");
+    let current = hc.increment(msg);
+    current = hc.increment(current);
+    current = hc.increment(current); // hop 3
+    if (!hc.isExceeded(current)) {
+        console.log("      ✗ Should be exceeded at hop 3");
+        pass = false;
+    }
+    else
+        console.log("      ✓ Exceeded at hop 3 (limit reached)");
+    // Cycle detection
+    const msgWithPath = {
+        id: "test-msg-2",
+        taskId: "task-1",
+        conversationId: "conv-1",
+        from: "agent-a",
+        to: "agent-b",
+        type: "TASK",
+        payload: {},
+        metadata: { hopCount: 1, maxHops: 10, priority: 5, routingPath: ["agent-a", "agent-b", "agent-c"] },
+        timestamp: Date.now(),
+    };
+    if (!hc.wouldCreateCycle(msgWithPath, "agent-b")) {
+        console.log("      ✗ Cycle not detected");
+        pass = false;
+    }
+    else
+        console.log("      ✓ Cycle detection works");
+    // 4b: MessageDeduplicator
+    console.log("\n    [4b] MessageDeduplicator: duplicate detection");
+    const dedup = new MessageDeduplicator_1.MessageDeduplicator(5000);
+    const dup1 = makeEnvelope("a", "b", "t1", "c1", "TASK", { data: "hello" });
+    const dup2 = makeEnvelope("a", "b", "t1", "c1", "TASK", { data: "hello" });
+    const diff = makeEnvelope("a", "b", "t1", "c1", "TASK", { data: "world" });
+    if (dedup.isDuplicate(dup1)) {
+        console.log("      ✗ First message flagged as dup");
+        pass = false;
+    }
+    else
+        console.log("      ✓ First message not duplicate");
+    if (!dedup.isDuplicate(dup2)) {
+        console.log("      ✗ Duplicate not detected");
+        pass = false;
+    }
+    else
+        console.log("      ✓ Duplicate detected");
+    if (dedup.isDuplicate(diff)) {
+        console.log("      ✗ Different message flagged as dup");
+        pass = false;
+    }
+    else
+        console.log("      ✓ Different message not duplicate");
+    // 4c: CircuitBreaker
+    console.log("\n    [4c] CircuitBreaker: state transitions");
+    const cb = new CircuitBreaker_1.CircuitBreaker({ threshold: 3, cooldownMs: 100 });
+    if (!cb.isAvailable("agent-1")) {
+        console.log("      ✗ Should be available initially");
+        pass = false;
+    }
+    else
+        console.log("      ✓ Initially available (closed)");
+    cb.recordFailure("agent-1");
+    cb.recordFailure("agent-1");
+    if (!cb.isAvailable("agent-1")) {
+        console.log("      ✗ Should still be available after 2 failures");
+        pass = false;
+    }
+    else
+        console.log("      ✓ Still available after 2 failures");
+    cb.recordFailure("agent-1"); // 3rd → open
+    if (cb.isAvailable("agent-1")) {
+        console.log("      ✗ Should be unavailable after 3 failures");
+        pass = false;
+    }
+    else
+        console.log("      ✓ Unavailable after threshold (open)");
+    cb.recordSuccess("agent-1");
+    if (!cb.isAvailable("agent-1")) {
+        console.log("      ✗ Should be available after success");
+        pass = false;
+    }
+    else
+        console.log("      ✓ Available after success (closed)");
+    // 4d: Broker safety integration
+    console.log("\n    [4d] Broker safety status");
+    cleanupBrokerState();
+    const broker = new Broker_1.Broker();
+    await broker.registerAdapter(new MockExecutor());
+    await broker.registerAdapter(new MockReviewer());
+    broker.addAgentProfile({ id: "executor", runtimeId: "executor", role: "executor", maxConcurrency: 1, status: "idle" });
+    broker.addAgentProfile({ id: "reviewer", runtimeId: "reviewer", role: "reviewer", maxConcurrency: 1, status: "idle" });
+    broker.addGraphEdge("executor", "reviewer", "reviews", 10);
+    broker.enableGraphMode();
+    const safety = broker.getSafetyStatus();
+    if (!safety.circuitBreaker || !safety.hopCounter || !safety.deduplicator) {
+        console.log("      ✗ Safety status incomplete");
+        pass = false;
+    }
+    else {
+        console.log("      ✓ Broker safety status available");
+    }
+    console.log(`\n  Test 4: ${pass ? "PASS ✓" : "FAIL ✗"}`);
+    return pass;
+}
+// ─── Test 5: v1.1 backward compatibility ──────────────
+async function test5_V11BackwardCompat() {
+    console.log("\n  [Test 5] V1.1 Backward Compatibility");
+    console.log("  ─────────────────────────────────────────────────────");
+    cleanupBrokerState();
+    const broker = new Broker_1.Broker();
+    let pass = true;
+    // Register adapters (v1.1 style — no graph mode)
+    await broker.registerAdapter(new MockExecutor());
+    await broker.registerAdapter(new MockReviewer());
+    // Link v1.1 style
+    broker.registry.link("executor", "reviewer");
+    // Should NOT be in graph mode
+    if (broker.isGraphMode()) {
+        console.log("    ✗ Should not be in graph mode");
+        pass = false;
+    }
+    else
+        console.log("    ✓ Not in graph mode (v1.1 compat)");
+    // Submit and run v1.1 style
+    broker.submit({
+        instruction: "Create a utility function",
+        executor: "executor",
+        reviewer: "reviewer",
+    });
+    await broker.run();
+    const tasks = broker.listTasks();
+    if (tasks.length !== 1) {
+        console.log(`    ✗ Task count: ${tasks.length}`);
+        pass = false;
+    }
+    else if (tasks[0].status !== "COMPLETED") {
+        console.log(`    ✗ Task status: ${tasks[0].status}`);
+        pass = false;
+    }
+    else
+        console.log("    ✓ Task completed via v1.1 path");
+    // Verify no graph artifacts
+    const convs = broker.getConversations().all();
+    if (convs.length !== 0) {
+        console.log(`    ✗ Conversations created in v1.1 mode: ${convs.length}`);
+        pass = false;
+    }
+    else
+        console.log("    ✓ No conversations in v1.1 mode");
+    console.log(`\n  Test 5: ${pass ? "PASS ✓" : "FAIL ✗"}`);
+    return pass;
+}
+// ─── Helper ───────────────────────────────────────────
+function makeEnvelope(from, to, taskId, convId, type, payload) {
+    return {
+        id: `env-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+        taskId,
+        conversationId: convId,
+        from,
+        to,
+        type,
+        payload,
+        metadata: { hopCount: 0, maxHops: 10, priority: 5, routingPath: [from] },
+        timestamp: Date.now(),
+    };
+}
+// ─── Main ──────────────────────────────────────────────
+async function main() {
+    console.log("═══════════════════════════════════════════");
+    console.log("  Test Suite: V2.0 Integration (Phase B)");
+    console.log("═══════════════════════════════════════════");
+    const results = [];
+    results.push(await test1_MultiAgentGraphTask());
+    results.push(await test2_EscalationPolicy());
+    results.push(await test3_MultiReviewerConsensus());
+    results.push(await test4_SafetyLayerIntegration());
+    results.push(await test5_V11BackwardCompat());
+    // Cleanup
+    cleanupBrokerState();
+    const passed = results.filter(Boolean).length;
+    const total = results.length;
+    console.log("\n═══════════════════════════════════════════");
+    console.log(`  Results: ${passed}/${total} passed`);
+    console.log("═══════════════════════════════════════════\n");
+    if (passed < total)
+        process.exit(1);
+}
+main().catch(err => { console.error("Fatal:", err); process.exit(1); });
+//# sourceMappingURL=test-v2-integration.js.map