pulseed 0.4.3 → 0.4.4

package/dist/orchestrator/strategy/__tests__/strategy-manager-phase2.test.js

@@ -1,602 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import * as fs from "node:fs";
-import { StateManager } from "../../../base/state/state-manager.js";
-import { StrategyManager } from "../strategy-manager.js";
-import { createMockLLMClient } from "../../../../tests/helpers/mock-llm.js";
-import { makeTempDir } from "../../../../tests/helpers/temp-dir.js";
-// ─── Fixtures ───
-const CANDIDATE_RESPONSE_ONE = `\`\`\`json
-[
-  {
-    "hypothesis": "Increase daily writing output by dedicating the first 2 hours of each day to writing",
-    "expected_effect": [
-      { "dimension": "word_count", "direction": "increase", "magnitude": "medium" }
-    ],
-    "resource_estimate": {
-      "sessions": 10,
-      "duration": { "value": 14, "unit": "days" },
-      "llm_calls": null
-    },
-    "allocation": 0.8
-  }
-]
-\`\`\``;
-const CANDIDATE_RESPONSE_TWO = `\`\`\`json
-[
-  {
-    "hypothesis": "Use the Pomodoro technique for focused research sessions",
-    "expected_effect": [
-      { "dimension": "research_depth", "direction": "increase", "magnitude": "large" }
-    ],
-    "resource_estimate": {
-      "sessions": 5,
-      "duration": { "value": 7, "unit": "days" },
-      "llm_calls": 2
-    },
-    "allocation": 0.6
-  },
-  {
-    "hypothesis": "Create a structured outline before each writing session",
-    "expected_effect": [
-      { "dimension": "word_count", "direction": "increase", "magnitude": "small" }
-    ],
-    "resource_estimate": {
-      "sessions": 3,
-      "duration": { "value": 3, "unit": "days" },
-      "llm_calls": null
-    },
-    "allocation": 0.4
-  }
-]
-\`\`\``;
-// ─── Test Setup ───
-let tempDir;
-let stateManager;
-beforeEach(() => {
-    tempDir = makeTempDir();
-    stateManager = new StateManager(tempDir);
-});
-afterEach(() => {
-    fs.rmSync(tempDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-});
-// ─── Phase 2 methods ───
-describe("Phase 2 methods", () => {
-    describe("activateMultiple", () => {
-        it("activates single strategy with allocation 1.0", async () => {
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_ONE]);
-            const manager = new StrategyManager(stateManager, mock);
-            const [candidate] = await manager.generateCandidates("goal-1", "word_count", ["word_count"], {
-                currentGap: 0.7,
-                pastStrategies: [],
-            });
-            const activated = await manager.activateMultiple("goal-1", [candidate.id]);
-            expect(activated).toHaveLength(1);
-            expect(activated[0].state).toBe("active");
-            expect(activated[0].allocation).toBe(1.0);
-        });
-        it("activates multiple strategies with equal split", async () => {
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_TWO]);
-            const manager = new StrategyManager(stateManager, mock);
-            const candidates = await manager.generateCandidates("goal-1", "research_depth", ["research_depth"], {
-                currentGap: 0.5,
-                pastStrategies: [],
-            });
-            const activated = await manager.activateMultiple("goal-1", candidates.map((c) => c.id));
-            expect(activated).toHaveLength(2);
-            expect(activated[0].allocation).toBeCloseTo(0.5, 5);
-            expect(activated[1].allocation).toBeCloseTo(0.5, 5);
-        });
-        it("respects min 0.1 and max 0.7 constraints", async () => {
-            // With 2 candidates, 1/2 = 0.5 which is within [0.1, 0.7], so no clamping needed
-            // Test min: can't test easily without 10+ candidates; test max with single candidate (1.0, no max clamp for single)
-            // Test that equal split for 2 does NOT exceed 0.7
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_TWO]);
-            const manager = new StrategyManager(stateManager, mock);
-            const candidates = await manager.generateCandidates("goal-1", "research_depth", ["research_depth"], {
-                currentGap: 0.5,
-                pastStrategies: [],
-            });
-            const activated = await manager.activateMultiple("goal-1", candidates.map((c) => c.id));
-            for (const s of activated) {
-                expect(s.allocation).toBeGreaterThanOrEqual(0.1);
-                expect(s.allocation).toBeLessThanOrEqual(0.7);
-            }
-        });
-        it("throws when strategyIds is empty", async () => {
-            const mock = createMockLLMClient([]);
-            const manager = new StrategyManager(stateManager, mock);
-            await expect(async () => await manager.activateMultiple("goal-1", [])).rejects.toThrow();
-        });
-        it("leaves non-targeted strategies unchanged when activating a subset of candidates", async () => {
-            // Generate two candidates, activate only one — the other should stay as candidate
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_TWO]);
-            const manager = new StrategyManager(stateManager, mock);
-            const candidates = await manager.generateCandidates("goal-1", "research_depth", ["research_depth"], {
-                currentGap: 0.5,
-                pastStrategies: [],
-            });
-            // Activate only the first candidate
-            const activated = await manager.activateMultiple("goal-1", [candidates[0].id]);
-            expect(activated).toHaveLength(1);
-            expect(activated[0].state).toBe("active");
-            // Second candidate should remain as candidate
-            const portfolio = await manager.getPortfolio("goal-1");
-            const second = portfolio.strategies.find((s) => s.id === candidates[1].id);
-            expect(second.state).toBe("candidate");
-        });
-        it("throws when a strategy is not in candidate state", async () => {
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_ONE]);
-            const manager = new StrategyManager(stateManager, mock);
-            const [candidate] = await manager.generateCandidates("goal-1", "word_count", ["word_count"], {
-                currentGap: 0.7,
-                pastStrategies: [],
-            });
-            // First activation succeeds
-            await manager.activateMultiple("goal-1", [candidate.id]);
-            // Second attempt on already-active strategy throws
-            await expect(async () => await manager.activateMultiple("goal-1", [candidate.id])).rejects.toThrow("not in candidate state");
-        });
-    });
-    describe("terminateStrategy", () => {
-        it("sets state to terminated", async () => {
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_ONE]);
-            const manager = new StrategyManager(stateManager, mock);
-            const [candidate] = await manager.generateCandidates("goal-1", "word_count", ["word_count"], {
-                currentGap: 0.7,
-                pastStrategies: [],
-            });
-            await manager.updateState(candidate.id, "active");
-            const terminated = await manager.terminateStrategy("goal-1", candidate.id, "test reason");
-            expect(terminated.state).toBe("terminated");
-        });
-        it("redistributes allocation to remaining active strategies", async () => {
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_TWO]);
-            const manager = new StrategyManager(stateManager, mock);
-            const candidates = await manager.generateCandidates("goal-1", "research_depth", ["research_depth"], {
-                currentGap: 0.5,
-                pastStrategies: [],
-            });
-            // Activate both with equal split (0.5 each)
-            await manager.activateMultiple("goal-1", candidates.map((c) => c.id));
-            // Terminate first; second should get all its allocation
-            await manager.terminateStrategy("goal-1", candidates[0].id, "test reason");
-            const portfolio = await manager.getPortfolio("goal-1");
-            const remaining = portfolio.strategies.find((s) => s.id === candidates[1].id);
-            expect(remaining.allocation).toBeGreaterThan(0.5);
-        });
-        it("handles last strategy termination (no redistribution)", async () => {
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_ONE]);
-            const manager = new StrategyManager(stateManager, mock);
-            const [candidate] = await manager.generateCandidates("goal-1", "word_count", ["word_count"], {
-                currentGap: 0.7,
-                pastStrategies: [],
-            });
-            await manager.activateMultiple("goal-1", [candidate.id]);
-            // Should not throw even with no remaining strategies
-            await expect(manager.terminateStrategy("goal-1", candidate.id, "last strategy")).resolves.toBeDefined();
-            const history = await manager.getStrategyHistory("goal-1");
-            expect(history.some((s) => s.state === "terminated")).toBe(true);
-        });
-        it("archives terminated strategy to history", async () => {
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_ONE]);
-            const manager = new StrategyManager(stateManager, mock);
-            const [candidate] = await manager.generateCandidates("goal-1", "word_count", ["word_count"], {
-                currentGap: 0.7,
-                pastStrategies: [],
-            });
-            await manager.updateState(candidate.id, "active");
-            await manager.terminateStrategy("goal-1", candidate.id, "test reason");
-            const history = await manager.getStrategyHistory("goal-1");
-            expect(history.some((s) => s.id === candidate.id && s.state === "terminated")).toBe(true);
-        });
-    });
-    describe("createWaitStrategy", () => {
-        it("creates strategy with wait fields", async () => {
-            const mock = createMockLLMClient([]);
-            const manager = new StrategyManager(stateManager, mock);
-            const result = await manager.createWaitStrategy("goal-1", {
-                hypothesis: "Wait for external data",
-                wait_reason: "Awaiting market data",
-                wait_until: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
-                measurement_plan: "Check market data API",
-                fallback_strategy_id: null,
-                target_dimensions: ["word_count"],
-                primary_dimension: "word_count",
-            });
-            expect(result).toBeDefined();
-            expect(result.hypothesis).toBe("Wait for external data");
-        });
-        it("sets state to candidate", async () => {
-            const mock = createMockLLMClient([]);
-            const manager = new StrategyManager(stateManager, mock);
-            const result = await manager.createWaitStrategy("goal-1", {
-                hypothesis: "Wait for external data",
-                wait_reason: "Awaiting market data",
-                wait_until: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
-                measurement_plan: "Check market data API",
-                fallback_strategy_id: null,
-                target_dimensions: ["word_count"],
-                primary_dimension: "word_count",
-            });
-            expect(result.state).toBe("candidate");
-        });
-        it("stores in portfolio", async () => {
-            const mock = createMockLLMClient([]);
-            const manager = new StrategyManager(stateManager, mock);
-            const result = await manager.createWaitStrategy("goal-1", {
-                hypothesis: "Wait for external data",
-                wait_reason: "Awaiting market data",
-                wait_until: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
-                measurement_plan: "Check market data API",
-                fallback_strategy_id: null,
-                target_dimensions: ["word_count"],
-                primary_dimension: "word_count",
-            });
-            const portfolio = await manager.getPortfolio("goal-1");
-            expect(portfolio).not.toBeNull();
-            expect(portfolio.strategies.some((s) => s.id === result.id)).toBe(true);
-        });
-        it("assigns unique ID", async () => {
-            const mock = createMockLLMClient([]);
-            const manager = new StrategyManager(stateManager, mock);
-            const params = {
-                hypothesis: "Wait",
-                wait_reason: "reason",
-                wait_until: new Date(Date.now() + 86400000).toISOString(),
-                measurement_plan: "plan",
-                fallback_strategy_id: null,
-                target_dimensions: ["dim1"],
-                primary_dimension: "dim1",
-            };
-            const s1 = await manager.createWaitStrategy("goal-1", params);
-            const s2 = await manager.createWaitStrategy("goal-1", params);
-            expect(s1.id).not.toBe(s2.id);
-        });
-    });
-    describe("suspendStrategy", () => {
-        it("sets state to suspended", async () => {
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_ONE]);
-            const manager = new StrategyManager(stateManager, mock);
-            const [candidate] = await manager.generateCandidates("goal-1", "word_count", ["word_count"], {
-                currentGap: 0.7,
-                pastStrategies: [],
-            });
-            await manager.updateState(candidate.id, "active");
-            const suspended = await manager.suspendStrategy("goal-1", candidate.id);
-            expect(suspended.state).toBe("suspended");
-        });
-        it("redistributes allocation to remaining active strategies", async () => {
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_TWO]);
-            const manager = new StrategyManager(stateManager, mock);
-            const candidates = await manager.generateCandidates("goal-1", "research_depth", ["research_depth"], {
-                currentGap: 0.5,
-                pastStrategies: [],
-            });
-            await manager.activateMultiple("goal-1", candidates.map((c) => c.id));
-            await manager.suspendStrategy("goal-1", candidates[0].id);
-            const portfolio = await manager.getPortfolio("goal-1");
-            const remaining = portfolio.strategies.find((s) => s.id === candidates[1].id);
-            expect(remaining.allocation).toBeGreaterThan(0.5);
-        });
-        it("throws when strategy not found", async () => {
-            const mock = createMockLLMClient([]);
-            const manager = new StrategyManager(stateManager, mock);
-            await expect(async () => await manager.suspendStrategy("goal-1", "nonexistent-id")).rejects.toThrow("not found");
-        });
-        it("throws when strategy is not active or evaluating", async () => {
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_ONE]);
-            const manager = new StrategyManager(stateManager, mock);
-            const [candidate] = await manager.generateCandidates("goal-1", "word_count", ["word_count"], {
-                currentGap: 0.7,
-                pastStrategies: [],
-            });
-            // candidate state is not active — should throw
-            await expect(async () => await manager.suspendStrategy("goal-1", candidate.id)).rejects.toThrow();
-        });
-    });
-    describe("resumeStrategy", () => {
-        it("restores to active state", async () => {
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_TWO]);
-            const manager = new StrategyManager(stateManager, mock);
-            const candidates = await manager.generateCandidates("goal-1", "research_depth", ["research_depth"], {
-                currentGap: 0.5,
-                pastStrategies: [],
-            });
-            await manager.activateMultiple("goal-1", candidates.map((c) => c.id));
-            await manager.suspendStrategy("goal-1", candidates[0].id);
-            const resumed = await manager.resumeStrategy("goal-1", candidates[0].id, 0.4);
-            expect(resumed.state).toBe("active");
-            expect(resumed.allocation).toBe(0.4);
-        });
-        it("adjusts other allocations to maintain sum close to 1.0", async () => {
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_TWO]);
-            const manager = new StrategyManager(stateManager, mock);
-            const candidates = await manager.generateCandidates("goal-1", "research_depth", ["research_depth"], {
-                currentGap: 0.5,
-                pastStrategies: [],
-            });
-            await manager.activateMultiple("goal-1", candidates.map((c) => c.id));
-            await manager.suspendStrategy("goal-1", candidates[0].id);
-            await manager.resumeStrategy("goal-1", candidates[0].id, 0.4);
-            const portfolio = await manager.getPortfolio("goal-1");
-            const active = portfolio.strategies.filter((s) => s.state === "active" || s.state === "evaluating");
-            const totalAlloc = active.reduce((sum, s) => sum + s.allocation, 0);
-            expect(totalAlloc).toBeCloseTo(1.0, 5);
-        });
-        it("throws when strategy is not suspended", async () => {
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_ONE]);
-            const manager = new StrategyManager(stateManager, mock);
-            const [candidate] = await manager.generateCandidates("goal-1", "word_count", ["word_count"], {
-                currentGap: 0.7,
-                pastStrategies: [],
-            });
-            await manager.updateState(candidate.id, "active");
-            await expect(async () => await manager.resumeStrategy("goal-1", candidate.id, 0.5)).rejects.toThrow("must be suspended");
-        });
-    });
-    describe("getAllActiveStrategies", () => {
-        it("returns active and evaluating strategies", async () => {
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_TWO]);
-            const manager = new StrategyManager(stateManager, mock);
-            const candidates = await manager.generateCandidates("goal-1", "research_depth", ["research_depth"], {
-                currentGap: 0.5,
-                pastStrategies: [],
-            });
-            await manager.activateMultiple("goal-1", candidates.map((c) => c.id));
-            // Move first to evaluating
-            await manager.updateState(candidates[0].id, "evaluating");
-            const active = await manager.getAllActiveStrategies("goal-1");
-            expect(active).toHaveLength(2);
-            const states = active.map((s) => s.state);
-            expect(states).toContain("evaluating");
-            expect(states).toContain("active");
-        });
-        it("excludes suspended/terminated/candidate strategies", async () => {
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_TWO]);
-            const manager = new StrategyManager(stateManager, mock);
-            const candidates = await manager.generateCandidates("goal-1", "research_depth", ["research_depth"], {
-                currentGap: 0.5,
-                pastStrategies: [],
-            });
-            // Activate both, then suspend one
-            await manager.activateMultiple("goal-1", candidates.map((c) => c.id));
-            await manager.suspendStrategy("goal-1", candidates[0].id);
-            const active = await manager.getAllActiveStrategies("goal-1");
-            // Only the non-suspended one should appear
-            expect(active).toHaveLength(1);
-            expect(active[0].id).toBe(candidates[1].id);
-        });
-        it("returns empty array when no active strategies exist", async () => {
-            const mock = createMockLLMClient([]);
-            const manager = new StrategyManager(stateManager, mock);
-            expect(await manager.getAllActiveStrategies("goal-1")).toEqual([]);
-        });
-    });
-    describe("updateAllocation", () => {
-        it("updates allocation for specific strategy", async () => {
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_ONE]);
-            const manager = new StrategyManager(stateManager, mock);
-            const [candidate] = await manager.generateCandidates("goal-1", "word_count", ["word_count"], {
-                currentGap: 0.7,
-                pastStrategies: [],
-            });
-            await manager.updateState(candidate.id, "active");
-            await manager.updateAllocation("goal-1", candidate.id, 0.6);
-            const portfolio = await manager.getPortfolio("goal-1");
-            const updated = portfolio.strategies.find((s) => s.id === candidate.id);
-            expect(updated.allocation).toBe(0.6);
-        });
-        it("throws when allocation is out of [0, 1] range", async () => {
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_ONE]);
-            const manager = new StrategyManager(stateManager, mock);
-            const [candidate] = await manager.generateCandidates("goal-1", "word_count", ["word_count"], {
-                currentGap: 0.7,
-                pastStrategies: [],
-            });
-            await expect(async () => await manager.updateAllocation("goal-1", candidate.id, 1.5)).rejects.toThrow("allocation must be in [0, 1]");
-        });
-        it("throws when strategy not found", async () => {
-            const mock = createMockLLMClient([]);
-            const manager = new StrategyManager(stateManager, mock);
-            await expect(async () => await manager.updateAllocation("goal-1", "nonexistent-id", 0.5)).rejects.toThrow("not found");
-        });
-        it("leaves other strategies untouched when updating allocation in a multi-strategy portfolio", async () => {
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_TWO]);
-            const manager = new StrategyManager(stateManager, mock);
-            const candidates = await manager.generateCandidates("goal-1", "research_depth", ["research_depth"], {
-                currentGap: 0.5,
-                pastStrategies: [],
-            });
-            await manager.activateMultiple("goal-1", candidates.map((c) => c.id));
-            const targetId = candidates[0].id;
-            const otherId = candidates[1].id;
-            await manager.updateAllocation("goal-1", targetId, 0.3);
-            const portfolio = await manager.getPortfolio("goal-1");
-            const target = portfolio.strategies.find((s) => s.id === targetId);
-            const other = portfolio.strategies.find((s) => s.id === otherId);
-            expect(target.allocation).toBe(0.3);
-            // other strategy allocation is unchanged
-            expect(other.allocation).toBeCloseTo(0.5, 5);
-        });
-        it("persists updated allocation across manager instances", async () => {
-            const mock = createMockLLMClient([CANDIDATE_RESPONSE_ONE]);
-            const manager1 = new StrategyManager(stateManager, mock);
-            const [candidate] = await manager1.generateCandidates("goal-1", "word_count", ["word_count"], {
-                currentGap: 0.7,
-                pastStrategies: [],
-            });
-            await manager1.updateState(candidate.id, "active");
-            await manager1.updateAllocation("goal-1", candidate.id, 0.55);
-            const manager2 = new StrategyManager(stateManager, createMockLLMClient([]));
-            const portfolio = await manager2.getPortfolio("goal-1");
-            const strategy = portfolio.strategies.find((s) => s.id === candidate.id);
-            expect(strategy.allocation).toBe(0.55);
-        });
-    });
-});
-// ─── Additional branch coverage ───
-describe("activateMultiple — strategy not found in portfolio", () => {
-    it("throws when a strategy ID does not exist in the portfolio", async () => {
-        const mock = createMockLLMClient([]);
-        const manager = new StrategyManager(stateManager, mock);
-        // Portfolio for goal-1 exists (will be created) but "ghost-id" is not in it
-        await expect(manager.activateMultiple("goal-1", ["ghost-id"])).rejects.toThrow("not found in portfolio");
-    });
-});
-describe("terminateStrategy — strategy not found", () => {
-    it("throws when strategy ID does not exist in the portfolio", async () => {
-        const mock = createMockLLMClient([CANDIDATE_RESPONSE_ONE]);
-        const manager = new StrategyManager(stateManager, mock);
-        // Create portfolio with one candidate
-        await manager.generateCandidates("goal-1", "word_count", ["word_count"], {
-            currentGap: 0.7,
-            pastStrategies: [],
-        });
-        await expect(manager.terminateStrategy("goal-1", "nonexistent-id", "reason")).rejects.toThrow("not found in portfolio");
-    });
-});
-describe("resumeStrategy — error paths", () => {
-    it("throws when allocation is negative", async () => {
-        const mock = createMockLLMClient([]);
-        const manager = new StrategyManager(stateManager, mock);
-        await expect(manager.resumeStrategy("goal-1", "any-id", -0.1)).rejects.toThrow("allocation must be in [0, 1]");
-    });
-    it("throws when allocation exceeds 1", async () => {
-        const mock = createMockLLMClient([]);
-        const manager = new StrategyManager(stateManager, mock);
-        await expect(manager.resumeStrategy("goal-1", "any-id", 1.01)).rejects.toThrow("allocation must be in [0, 1]");
-    });
-    it("throws when strategy ID does not exist in portfolio", async () => {
-        const mock = createMockLLMClient([CANDIDATE_RESPONSE_ONE]);
-        const manager = new StrategyManager(stateManager, mock);
-        await manager.generateCandidates("goal-1", "word_count", ["word_count"], {
-            currentGap: 0.7,
-            pastStrategies: [],
-        });
-        await expect(manager.resumeStrategy("goal-1", "nonexistent-id", 0.5)).rejects.toThrow("not found in portfolio");
-    });
-    it("leaves non-active strategies unchanged when resuming (covers !others.some branch)", async () => {
-        // Set up: two candidates, one active, one suspended, plus a third candidate (non-active)
-        // The third candidate should be returned unchanged during the strategy map in resumeStrategy
-        const mock = createMockLLMClient([CANDIDATE_RESPONSE_TWO, CANDIDATE_RESPONSE_ONE]);
-        const manager = new StrategyManager(stateManager, mock);
-        const firstBatch = await manager.generateCandidates("goal-1", "research_depth", ["research_depth"], {
-            currentGap: 0.5,
-            pastStrategies: [],
-        });
-        // Activate both from firstBatch
-        await manager.activateMultiple("goal-1", firstBatch.map((c) => c.id));
-        // Generate a third candidate (remains in candidate state — not active/evaluating)
-        const secondBatch = await manager.generateCandidates("goal-1", "word_count", ["word_count"], {
-            currentGap: 0.7,
-            pastStrategies: [],
-        });
-        const thirdCandidateId = secondBatch[0].id;
-        // Suspend first strategy
-        await manager.suspendStrategy("goal-1", firstBatch[0].id);
-        // Resume first strategy — third candidate should pass through unchanged
-        const resumed = await manager.resumeStrategy("goal-1", firstBatch[0].id, 0.3);
-        expect(resumed.state).toBe("active");
-        // Verify the third candidate (non-active) is still in candidate state
-        const portfolio = await manager.getPortfolio("goal-1");
-        const third = portfolio.strategies.find((s) => s.id === thirdCandidateId);
-        expect(third.state).toBe("candidate");
-    });
-    it("uses equal split when totalOtherAlloc is zero (no other active strategies)", async () => {
-        // Suspend the only active strategy, then resume it — no others exist so totalOtherAlloc = 0
-        const mock = createMockLLMClient([CANDIDATE_RESPONSE_ONE]);
-        const manager = new StrategyManager(stateManager, mock);
-        const [candidate] = await manager.generateCandidates("goal-1", "word_count", ["word_count"], {
-            currentGap: 0.7,
-            pastStrategies: [],
-        });
-        await manager.updateState(candidate.id, "active");
-        await manager.suspendStrategy("goal-1", candidate.id);
-        // Resume with allocation 0.6; no other active strategies (totalOtherAlloc = 0)
-        const resumed = await manager.resumeStrategy("goal-1", candidate.id, 0.6);
-        expect(resumed.state).toBe("active");
-        expect(resumed.allocation).toBe(0.6);
-    });
-    it("uses equal-split fallback when other active strategies have zero allocation", async () => {
-        // Set up two active strategies, force the non-target one to have allocation 0
-        const mock = createMockLLMClient([CANDIDATE_RESPONSE_TWO]);
-        const manager = new StrategyManager(stateManager, mock);
-        const candidates = await manager.generateCandidates("goal-1", "research_depth", ["research_depth"], {
-            currentGap: 0.5,
-            pastStrategies: [],
-        });
-        await manager.activateMultiple("goal-1", candidates.map((c) => c.id));
-        // Force id2's allocation to 0 via updateAllocation
-        await manager.updateAllocation("goal-1", candidates[1].id, 0);
-        // Suspend id1
-        await manager.suspendStrategy("goal-1", candidates[0].id);
-        // Resume id1: others=[id2] with allocation=0 → totalOtherAlloc=0 → uses equal split fallback
-        const resumed = await manager.resumeStrategy("goal-1", candidates[0].id, 0.4);
-        expect(resumed.state).toBe("active");
-        expect(resumed.allocation).toBe(0.4);
-        const portfolio = await manager.getPortfolio("goal-1");
-        const other = portfolio.strategies.find((s) => s.id === candidates[1].id);
-        // remaining = 1 - 0.4 = 0.6; split equally among 1 other → 0.6
-        expect(other.allocation).toBeCloseTo(0.6, 5);
-    });
-});
-// ─── getStrategyHistory ───
-describe("getStrategyHistory", () => {
-    it("returns empty array when no history exists", async () => {
-        const mock = createMockLLMClient([]);
-        const manager = new StrategyManager(stateManager, mock);
-        expect(await manager.getStrategyHistory("goal-1")).toEqual([]);
-    });
-    it("includes terminated strategies in history", async () => {
-        const mock = createMockLLMClient([CANDIDATE_RESPONSE_ONE]);
-        const manager = new StrategyManager(stateManager, mock);
-        const [candidate] = await manager.generateCandidates("goal-1", "word_count", ["word_count"], {
-            currentGap: 0.7,
-            pastStrategies: [],
-        });
-        await manager.updateState(candidate.id, "active");
-        await manager.updateState(candidate.id, "terminated");
-        const history = await manager.getStrategyHistory("goal-1");
-        expect(history).toHaveLength(1);
-        expect(history[0].state).toBe("terminated");
-    });
-    it("includes completed strategies in history", async () => {
-        const mock = createMockLLMClient([CANDIDATE_RESPONSE_ONE]);
-        const manager = new StrategyManager(stateManager, mock);
-        const [candidate] = await manager.generateCandidates("goal-1", "word_count", ["word_count"], {
-            currentGap: 0.7,
-            pastStrategies: [],
-        });
-        await manager.updateState(candidate.id, "active");
-        await manager.updateState(candidate.id, "completed");
-        const history = await manager.getStrategyHistory("goal-1");
-        expect(history).toHaveLength(1);
-        expect(history[0].state).toBe("completed");
-    });
-    it("does not include candidate or active strategies in history", async () => {
-        const mock = createMockLLMClient([CANDIDATE_RESPONSE_TWO]);
-        const manager = new StrategyManager(stateManager, mock);
-        await manager.generateCandidates("goal-1", "research_depth", ["research_depth"], {
-            currentGap: 0.5,
-            pastStrategies: [],
-        });
-        await manager.activateBestCandidate("goal-1");
-        const history = await manager.getStrategyHistory("goal-1");
-        expect(history).toHaveLength(0);
-    });
-    it("persists history across manager instances", async () => {
-        const mock = createMockLLMClient([CANDIDATE_RESPONSE_ONE]);
-        const manager1 = new StrategyManager(stateManager, mock);
-        const [candidate] = await manager1.generateCandidates("goal-1", "word_count", ["word_count"], {
-            currentGap: 0.7,
-            pastStrategies: [],
-        });
-        await manager1.updateState(candidate.id, "active");
-        await manager1.updateState(candidate.id, "terminated");
-        const manager2 = new StrategyManager(stateManager, createMockLLMClient([]));
-        const history = await manager2.getStrategyHistory("goal-1");
-        expect(history).toHaveLength(1);
-        expect(history[0].state).toBe("terminated");
-    });
-});
-//# sourceMappingURL=strategy-manager-phase2.test.js.map