pulseed 0.4.2 → 0.4.4

package/dist/platform/drive/__tests__/stall-detector.test.js

@@ -1,903 +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 { StallDetector } from "../stall-detector.js";
-import { ProgressPredictor } from "../progress-predictor.js";
-import { makeTempDir } from "../../../../tests/helpers/temp-dir.js";
-function makeGapHistory(values) {
-    return values.map((v) => ({ normalized_gap: v }));
-}
-// ─── Test Setup ───
-let tempDir;
-let stateManager;
-let detector;
-beforeEach(() => {
-    tempDir = makeTempDir();
-    stateManager = new StateManager(tempDir);
-    detector = new StallDetector(stateManager);
-});
-afterEach(() => {
-    fs.rmSync(tempDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-});
-// ─── checkDimensionStall ───
-describe("checkDimensionStall", () => {
-    it("returns null when gap is improving (decreasing)", () => {
-        // 6 entries: gap going from 0.8 to 0.3
-        const history = makeGapHistory([0.8, 0.7, 0.6, 0.5, 0.4, 0.3]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history);
-        expect(result).toBeNull();
-    });
-    it("returns StallReport when gap has not decreased over N (default=5) loops", () => {
-        // Flat gap for 6 entries (oldest=0.5, latest=0.5)
-        const history = makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.5]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("dimension_stall");
-        expect(result.goal_id).toBe("goal-1");
-        expect(result.dimension_name).toBe("dim-a");
-        expect(result.decay_factor).toBe(0.6);
-    });
-    it("returns StallReport when gap slightly increased (got worse)", () => {
-        // Gap went up from 0.4 to 0.5 over the window
-        const history = makeGapHistory([0.4, 0.42, 0.45, 0.48, 0.5, 0.5]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("dimension_stall");
-    });
-    it("returns null when history is too short (fewer than N+1 entries)", () => {
-        // Default N=5, need at least 6 entries
-        const history = makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history);
-        expect(result).toBeNull();
-    });
-    it("uses N=6 for 'immediate' feedback category", () => {
-        // N=6 means need 7 entries; flat over 7 entries → stall
-        const history = makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history, "immediate");
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("dimension_stall");
-    });
-    it("uses N=6 for 'immediate': 4 entries is insufficient history → no stall", () => {
-        // N=6 → need 7 entries; 4 entries is not enough data
-        const history = makeGapHistory([0.5, 0.5, 0.5, 0.5]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history, "immediate");
-        expect(result).toBeNull();
-    });
-    it("uses N=6 for 'immediate': improving over 7 entries → no stall", () => {
-        const history = makeGapHistory([0.5, 0.45, 0.40, 0.35, 0.30, 0.25, 0.20]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history, "immediate");
-        expect(result).toBeNull();
-    });
-    it("uses N=10 for 'long_term' feedback category", () => {
-        // N=10 means need 11 entries; only 6 available → not enough data
-        const history = makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.5]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history, "long_term");
-        expect(result).toBeNull();
-    });
-    it("uses N=10 for 'long_term': stall detected with 11 flat entries", () => {
-        const history = makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history, "long_term");
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("dimension_stall");
-    });
-    it("uses N=5 for 'medium_term' feedback category", () => {
-        // N=5 means need 6 entries; improving → no stall
-        const history = makeGapHistory([0.5, 0.48, 0.46, 0.44, 0.42, 0.40]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history, "medium_term");
-        expect(result).toBeNull();
-    });
-    it("falls back to N=5 for unknown feedback category", () => {
-        // Unknown category → N=5 (default)
-        const history = makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.5]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history, "unknown_category");
-        expect(result).not.toBeNull();
-    });
-    it("should not stall within 5 iterations if no progress (new 6-iteration threshold)", () => {
-        // Default category N=5 → need 6 entries to detect stall.
-        // 5 flat entries (indices 0-4) = only 5 entries → insufficient history → no stall.
-        const history = makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history);
-        expect(result).toBeNull();
-    });
-    it("should stall after 6 iterations of no progress", () => {
-        // Default category N=5 → need 6 entries (N+1=6) → 6 flat entries → stall.
-        const history = makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.5]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("dimension_stall");
-    });
-    it("does not reset stall detection for trivial improvement below 0.05 delta", () => {
-        // Improvement of only 0.001 (from 0.5 to 0.499) — below MIN_IMPROVEMENT_DELTA → still stall
-        const history = makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.499]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("dimension_stall");
-    });
-    it("resets stall detection for meaningful improvement of >= 0.05 delta", () => {
-        // Improvement of 0.10 (from 0.5 to 0.40) — at or above MIN_IMPROVEMENT_DELTA → no stall
-        const history = makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.40]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history);
-        expect(result).toBeNull();
-    });
-});
-// ─── checkTimeExceeded ───
-describe("checkTimeExceeded", () => {
-    it("returns null when no started_at", () => {
-        const task = {
-            goal_id: "goal-1",
-            started_at: null,
-            estimated_duration: { value: 1, unit: "hours" },
-        };
-        expect(detector.checkTimeExceeded(task)).toBeNull();
-    });
-    it("returns null when elapsed time is within estimate×2 threshold", () => {
-        // Estimate = 1 hour, threshold = 2 hours, started 1 hour ago
-        const startedAt = new Date(Date.now() - 60 * 60 * 1000).toISOString();
-        const task = {
-            goal_id: "goal-1",
-            started_at: startedAt,
-            estimated_duration: { value: 1, unit: "hours" },
-        };
-        expect(detector.checkTimeExceeded(task)).toBeNull();
-    });
-    it("returns StallReport when elapsed time exceeds estimate×2", () => {
-        // Estimate = 1 hour → threshold = 2 hours; started 3 hours ago
-        const startedAt = new Date(Date.now() - 3 * 60 * 60 * 1000).toISOString();
-        const task = {
-            task_id: "task-123",
-            goal_id: "goal-1",
-            started_at: startedAt,
-            estimated_duration: { value: 1, unit: "hours" },
-        };
-        const result = detector.checkTimeExceeded(task);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("time_exceeded");
-        expect(result.task_id).toBe("task-123");
-        expect(result.suggested_cause).toBe("external_dependency");
-    });
-    it("uses default 2 hours for 'coding' category (no estimate)", () => {
-        // Started 1 hour ago → within 2h threshold → no stall
-        const startedAt = new Date(Date.now() - 1 * 60 * 60 * 1000).toISOString();
-        const task = { goal_id: "goal-1", started_at: startedAt, task_category: "coding" };
-        expect(detector.checkTimeExceeded(task)).toBeNull();
-    });
-    it("returns StallReport for 'coding' after exceeding 2 hours", () => {
-        // Started 3 hours ago → exceeds 2h threshold
-        const startedAt = new Date(Date.now() - 3 * 60 * 60 * 1000).toISOString();
-        const task = { goal_id: "goal-1", started_at: startedAt, task_category: "coding" };
-        const result = detector.checkTimeExceeded(task);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("time_exceeded");
-    });
-    it("uses default 2 hours for 'implementation' category", () => {
-        const startedAt = new Date(Date.now() - 3 * 60 * 60 * 1000).toISOString();
-        const task = { goal_id: "goal-1", started_at: startedAt, task_category: "implementation" };
-        const result = detector.checkTimeExceeded(task);
-        expect(result).not.toBeNull();
-    });
-    it("uses default 4 hours for 'research' category", () => {
-        // Started 3 hours ago → within 4h → no stall
-        const startedAt = new Date(Date.now() - 3 * 60 * 60 * 1000).toISOString();
-        const task = { goal_id: "goal-1", started_at: startedAt, task_category: "research" };
-        expect(detector.checkTimeExceeded(task)).toBeNull();
-    });
-    it("returns StallReport for 'research' after exceeding 4 hours", () => {
-        const startedAt = new Date(Date.now() - 5 * 60 * 60 * 1000).toISOString();
-        const task = { goal_id: "goal-1", started_at: startedAt, task_category: "research" };
-        const result = detector.checkTimeExceeded(task);
-        expect(result).not.toBeNull();
-    });
-    it("uses default 4 hours for 'investigation' category", () => {
-        const startedAt = new Date(Date.now() - 5 * 60 * 60 * 1000).toISOString();
-        const task = { goal_id: "goal-1", started_at: startedAt, task_category: "investigation" };
-        const result = detector.checkTimeExceeded(task);
-        expect(result).not.toBeNull();
-    });
-    it("uses fallback 3 hours for unknown category", () => {
-        // Started 2 hours ago → within 3h → no stall
-        const startedAt = new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString();
-        const task = { goal_id: "goal-1", started_at: startedAt, task_category: "other" };
-        expect(detector.checkTimeExceeded(task)).toBeNull();
-    });
-    it("returns StallReport for unknown category after exceeding 3 hours", () => {
-        const startedAt = new Date(Date.now() - 4 * 60 * 60 * 1000).toISOString();
-        const task = { goal_id: "goal-1", started_at: startedAt };
-        const result = detector.checkTimeExceeded(task);
-        expect(result).not.toBeNull();
-    });
-    it("handles duration in minutes correctly (estimate × 2)", () => {
-        // Estimate = 60 minutes (1 hour) → threshold = 2 hours; started 3 hours ago
-        const startedAt = new Date(Date.now() - 3 * 60 * 60 * 1000).toISOString();
-        const task = {
-            goal_id: "goal-1",
-            started_at: startedAt,
-            estimated_duration: { value: 60, unit: "minutes" },
-        };
-        const result = detector.checkTimeExceeded(task);
-        expect(result).not.toBeNull();
-    });
-    it("handles duration in days correctly (estimate × 2)", () => {
-        // Estimate = 1 day → threshold = 2 days; started 1 day ago → no stall
-        const startedAt = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
-        const task = {
-            goal_id: "goal-1",
-            started_at: startedAt,
-            estimated_duration: { value: 1, unit: "days" },
-        };
-        expect(detector.checkTimeExceeded(task)).toBeNull();
-    });
-});
-// ─── checkConsecutiveFailures ───
-describe("checkConsecutiveFailures", () => {
-    it("returns null when count is below threshold (< 3)", () => {
-        expect(detector.checkConsecutiveFailures("goal-1", "dim-a", 2)).toBeNull();
-    });
-    it("returns null when count is 0", () => {
-        expect(detector.checkConsecutiveFailures("goal-1", "dim-a", 0)).toBeNull();
-    });
-    it("returns StallReport when count equals threshold (3)", () => {
-        const result = detector.checkConsecutiveFailures("goal-1", "dim-a", 3);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("consecutive_failure");
-        expect(result.goal_id).toBe("goal-1");
-        expect(result.dimension_name).toBe("dim-a");
-        expect(result.suggested_cause).toBe("approach_failure");
-    });
-    it("returns StallReport when count exceeds threshold (5)", () => {
-        const result = detector.checkConsecutiveFailures("goal-1", "dim-a", 5);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("consecutive_failure");
-    });
-});
-// ─── checkGlobalStall ───
-describe("checkGlobalStall", () => {
-    it("returns null for empty dimension map", () => {
-        const result = detector.checkGlobalStall("goal-1", new Map());
-        expect(result).toBeNull();
-    });
-    it("returns null when at least one dimension is improving", () => {
-        const dims = new Map([
-            ["dim-a", makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.5])],
-            ["dim-b", makeGapHistory([0.5, 0.4, 0.3, 0.2, 0.1, 0.05])], // improving
-        ]);
-        const result = detector.checkGlobalStall("goal-1", dims);
-        expect(result).toBeNull();
-    });
-    it("returns StallReport when all dimensions are flat for 5 loops", () => {
-        const dims = new Map([
-            ["dim-a", makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.5])],
-            ["dim-b", makeGapHistory([0.3, 0.3, 0.3, 0.3, 0.3, 0.3])],
-        ]);
-        const result = detector.checkGlobalStall("goal-1", dims);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("global_stall");
-        expect(result.goal_id).toBe("goal-1");
-        expect(result.suggested_cause).toBe("goal_infeasible");
-    });
-    it("returns null when a dimension has insufficient history", () => {
-        const dims = new Map([
-            ["dim-a", makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.5])],
-            ["dim-b", makeGapHistory([0.5, 0.5])], // too short
-        ]);
-        const result = detector.checkGlobalStall("goal-1", dims);
-        expect(result).toBeNull();
-    });
-    it("respects custom loopThreshold", () => {
-        // loopThreshold=3: need 4 entries; all flat over 4 entries → stall
-        const dims = new Map([
-            ["dim-a", makeGapHistory([0.5, 0.5, 0.5, 0.5])],
-            ["dim-b", makeGapHistory([0.3, 0.3, 0.3, 0.3])],
-        ]);
-        const result = detector.checkGlobalStall("goal-1", dims, 3);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("global_stall");
-    });
-});
-// ─── classifyStallCause ───
-describe("classifyStallCause", () => {
-    it("returns 'approach_failure' for dimension_stall with high-confidence dimensions", () => {
-        const goal = { dimensions: [{ confidence: 0.8 }, { confidence: 0.9 }] };
-        expect(detector.classifyStallCause("dimension_stall", goal)).toBe("approach_failure");
-    });
-    it("returns 'external_dependency' for time_exceeded", () => {
-        const goal = { dimensions: [{ confidence: 0.8 }] };
-        expect(detector.classifyStallCause("time_exceeded", goal)).toBe("external_dependency");
-    });
-    it("returns 'approach_failure' for consecutive_failure", () => {
-        const goal = { dimensions: [{ confidence: 0.7 }] };
-        expect(detector.classifyStallCause("consecutive_failure", goal)).toBe("approach_failure");
-    });
-    it("returns 'goal_infeasible' for global_stall", () => {
-        const goal = { dimensions: [{ confidence: 0.8 }] };
-        expect(detector.classifyStallCause("global_stall", goal)).toBe("goal_infeasible");
-    });
-    it("returns 'information_deficit' when any dimension has confidence < 0.5", () => {
-        const goal = { dimensions: [{ confidence: 0.8 }, { confidence: 0.3 }] };
-        expect(detector.classifyStallCause("dimension_stall", goal)).toBe("information_deficit");
-    });
-    it("returns 'information_deficit' even for time_exceeded if low-confidence dim exists", () => {
-        const goal = { dimensions: [{ confidence: 0.4 }] };
-        expect(detector.classifyStallCause("time_exceeded", goal)).toBe("information_deficit");
-    });
-    it("returns 'information_deficit' for global_stall with low-confidence dimension", () => {
-        const goal = { dimensions: [{ confidence: 0.1 }] };
-        expect(detector.classifyStallCause("global_stall", goal)).toBe("information_deficit");
-    });
-    it("returns 'approach_failure' as fallback for unknown stall type", () => {
-        const goal = { dimensions: [{ confidence: 0.9 }] };
-        expect(detector.classifyStallCause("unknown_type", goal)).toBe("approach_failure");
-    });
-    it("handles goal with no dimensions", () => {
-        const goal = {};
-        expect(detector.classifyStallCause("global_stall", goal)).toBe("goal_infeasible");
-    });
-    it("handles goal with dimensions lacking confidence property", () => {
-        const goal = { dimensions: [{}] };
-        expect(detector.classifyStallCause("dimension_stall", goal)).toBe("approach_failure");
-    });
-});
-// ─── computeDecayFactor ───
-describe("computeDecayFactor", () => {
-    it("returns 0.6 when stalled (regardless of loopsSinceRecovery)", () => {
-        expect(detector.computeDecayFactor(true, null)).toBe(0.6);
-        expect(detector.computeDecayFactor(true, 0)).toBe(0.6);
-        expect(detector.computeDecayFactor(true, 5)).toBe(0.6);
-    });
-    it("returns 1.0 when not stalled and no recovery (null)", () => {
-        expect(detector.computeDecayFactor(false, null)).toBe(1.0);
-    });
-    it("returns 0.75 at 0 loops since recovery", () => {
-        expect(detector.computeDecayFactor(false, 0)).toBe(0.75);
-    });
-    it("returns 0.75 at 1 loop since recovery (threshold 2 not reached)", () => {
-        expect(detector.computeDecayFactor(false, 1)).toBe(0.75);
-    });
-    it("returns 0.90 at 2 loops since recovery", () => {
-        expect(detector.computeDecayFactor(false, 2)).toBe(0.9);
-    });
-    it("returns 0.90 at 3 loops since recovery (threshold 4 not reached)", () => {
-        expect(detector.computeDecayFactor(false, 3)).toBe(0.9);
-    });
-    it("returns 1.0 at 4 loops since recovery", () => {
-        expect(detector.computeDecayFactor(false, 4)).toBe(1.0);
-    });
-    it("returns 1.0 at 10 loops since recovery", () => {
-        expect(detector.computeDecayFactor(false, 10)).toBe(1.0);
-    });
-});
-// ─── isSuppressed ───
-describe("isSuppressed", () => {
-    it("returns false when plateauUntil is null", () => {
-        expect(detector.isSuppressed(null)).toBe(false);
-    });
-    it("returns true when plateauUntil is in the future", () => {
-        const future = new Date(Date.now() + 60 * 60 * 1000).toISOString(); // 1 hour from now
-        expect(detector.isSuppressed(future)).toBe(true);
-    });
-    it("returns false when plateauUntil is in the past", () => {
-        const past = new Date(Date.now() - 60 * 60 * 1000).toISOString(); // 1 hour ago
-        expect(detector.isSuppressed(past)).toBe(false);
-    });
-    it("returns false when plateauUntil is exactly now (boundary)", () => {
-        // Using a time slightly in the past to avoid flakiness
-        const slightlyPast = new Date(Date.now() - 1000).toISOString();
-        expect(detector.isSuppressed(slightlyPast)).toBe(false);
-    });
-});
-// ─── getStallState / saveStallState ───
-describe("getStallState / saveStallState", () => {
-    it("returns default state when no state persisted", async () => {
-        const state = await detector.getStallState("goal-1");
-        expect(state.goal_id).toBe("goal-1");
-        expect(state.dimension_escalation).toEqual({});
-        expect(state.global_escalation).toBe(0);
-        expect(state.decay_factors).toEqual({});
-        expect(state.recovery_loops).toEqual({});
-    });
-    it("round-trips: save and load StallState", async () => {
-        const stateToSave = {
-            goal_id: "goal-2",
-            dimension_escalation: { "dim-a": 2, "dim-b": 1 },
-            global_escalation: 1,
-            decay_factors: { "dim-a": 0.6 },
-            recovery_loops: { "dim-b": 3 },
-        };
-        await detector.saveStallState("goal-2", stateToSave);
-        const loaded = await detector.getStallState("goal-2");
-        expect(loaded.goal_id).toBe("goal-2");
-        expect(loaded.dimension_escalation["dim-a"]).toBe(2);
-        expect(loaded.dimension_escalation["dim-b"]).toBe(1);
-        expect(loaded.global_escalation).toBe(1);
-        expect(loaded.decay_factors["dim-a"]).toBe(0.6);
-        expect(loaded.recovery_loops["dim-b"]).toBe(3);
-    });
-});
-// ─── getEscalationLevel / incrementEscalation / resetEscalation ───
-describe("escalation lifecycle", () => {
-    it("returns 0 for a fresh goal/dimension", async () => {
-        expect(await detector.getEscalationLevel("goal-1", "dim-a")).toBe(0);
-    });
-    it("increments escalation level from 0 to 1", async () => {
-        const newLevel = await detector.incrementEscalation("goal-1", "dim-a");
-        expect(newLevel).toBe(1);
-        expect(await detector.getEscalationLevel("goal-1", "dim-a")).toBe(1);
-    });
-    it("increments escalation level through full lifecycle", async () => {
-        expect(await detector.incrementEscalation("goal-1", "dim-a")).toBe(1);
-        expect(await detector.incrementEscalation("goal-1", "dim-a")).toBe(2);
-        expect(await detector.incrementEscalation("goal-1", "dim-a")).toBe(3);
-    });
-    it("caps escalation at 3", async () => {
-        await detector.incrementEscalation("goal-1", "dim-a");
-        await detector.incrementEscalation("goal-1", "dim-a");
-        await detector.incrementEscalation("goal-1", "dim-a");
-        const capped = await detector.incrementEscalation("goal-1", "dim-a"); // attempt 4th
-        expect(capped).toBe(3);
-        expect(await detector.getEscalationLevel("goal-1", "dim-a")).toBe(3);
-    });
-    it("resets escalation to 0", async () => {
-        await detector.incrementEscalation("goal-1", "dim-a");
-        await detector.incrementEscalation("goal-1", "dim-a");
-        await detector.resetEscalation("goal-1", "dim-a");
-        expect(await detector.getEscalationLevel("goal-1", "dim-a")).toBe(0);
-    });
-    it("does not affect other dimensions when resetting", async () => {
-        await detector.incrementEscalation("goal-1", "dim-a");
-        await detector.incrementEscalation("goal-1", "dim-b");
-        await detector.resetEscalation("goal-1", "dim-a");
-        expect(await detector.getEscalationLevel("goal-1", "dim-a")).toBe(0);
-        expect(await detector.getEscalationLevel("goal-1", "dim-b")).toBe(1);
-    });
-    it("persists escalation across detector instances", async () => {
-        await detector.incrementEscalation("goal-1", "dim-a");
-        await detector.incrementEscalation("goal-1", "dim-a");
-        // Create a new detector using the same stateManager
-        const detector2 = new StallDetector(stateManager);
-        expect(await detector2.getEscalationLevel("goal-1", "dim-a")).toBe(2);
-    });
-    it("escalation is independent per goal", async () => {
-        await detector.incrementEscalation("goal-1", "dim-a");
-        await detector.incrementEscalation("goal-1", "dim-a");
-        expect(await detector.getEscalationLevel("goal-2", "dim-a")).toBe(0);
-    });
-    it("can increment multiple dimensions independently", async () => {
-        await detector.incrementEscalation("goal-1", "dim-a");
-        await detector.incrementEscalation("goal-1", "dim-a");
-        await detector.incrementEscalation("goal-1", "dim-b");
-        expect(await detector.getEscalationLevel("goal-1", "dim-a")).toBe(2);
-        expect(await detector.getEscalationLevel("goal-1", "dim-b")).toBe(1);
-    });
-});
-// ─── StallReport shape validation ───
-describe("StallReport shape", () => {
-    it("dimension_stall report has all required fields", () => {
-        const history = makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.5]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history);
-        expect(result).not.toBeNull();
-        expect(typeof result.detected_at).toBe("string");
-        expect(result.escalation_level).toBeGreaterThanOrEqual(0);
-        expect(result.escalation_level).toBeLessThanOrEqual(3);
-        expect(result.decay_factor).toBe(0.6);
-    });
-    it("time_exceeded report has task_id when provided", () => {
-        const startedAt = new Date(Date.now() - 5 * 60 * 60 * 1000).toISOString();
-        const task = {
-            task_id: "my-task-id",
-            goal_id: "goal-1",
-            started_at: startedAt,
-            estimated_duration: { value: 1, unit: "hours" },
-        };
-        const result = detector.checkTimeExceeded(task);
-        expect(result.task_id).toBe("my-task-id");
-        expect(result.dimension_name).toBeNull();
-    });
-    it("consecutive_failure report includes dimension_name", () => {
-        const result = detector.checkConsecutiveFailures("goal-1", "dim-x", 3);
-        expect(result.dimension_name).toBe("dim-x");
-    });
-    it("global_stall report has null dimension_name and task_id", () => {
-        const dims = new Map([
-            ["dim-a", makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.5])],
-        ]);
-        const result = detector.checkGlobalStall("goal-1", dims);
-        expect(result.dimension_name).toBeNull();
-        expect(result.task_id).toBeNull();
-    });
-});
-// ─── CharacterConfig integration — StallDetector ───
-describe("StallDetector CharacterConfig integration", () => {
-    let tempDir2;
-    let stateManager2;
-    beforeEach(() => {
-        tempDir2 = makeTempDir();
-        stateManager2 = new StateManager(tempDir2);
-    });
-    afterEach(() => {
-        fs.rmSync(tempDir2, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-    });
-    it("constructor without characterConfig is backwards compatible (no error)", () => {
-        expect(() => new StallDetector(stateManager2)).not.toThrow();
-    });
-    it("default config (stall_flexibility=1) uses N=6 for immediate category", () => {
-        // stall_flexibility=1 → multiplier=1.0 → immediate N=6 (need 7 entries)
-        const detectorDefault = new StallDetector(stateManager2);
-        // 7 flat entries → stall with immediate (N=6, need 7 entries)
-        const history = makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]);
-        const result = detectorDefault.checkDimensionStall("goal-1", "dim-a", history, "immediate");
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("dimension_stall");
-    });
-    it("default config (stall_flexibility=1) — medium_term N=5, need 6 entries", () => {
-        const detectorDefault = new StallDetector(stateManager2);
-        const history = makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.5]);
-        const result = detectorDefault.checkDimensionStall("goal-1", "dim-a", history, "medium_term");
-        expect(result).not.toBeNull();
-    });
-    it("stall_flexibility=1 → N multiplier=1.0 (identical to no config)", () => {
-        const detectorFlex1 = new StallDetector(stateManager2, {
-            caution_level: 2,
-            stall_flexibility: 1,
-            communication_directness: 3,
-            proactivity_level: 2,
-        });
-        // immediate N=6 → need 7 entries
-        const history = makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]);
-        expect(detectorFlex1.checkDimensionStall("g", "d", history, "immediate")).not.toBeNull();
-    });
-    it("stall_flexibility=5 → multiplier=2.0 → immediate N=12 (need 13 entries)", () => {
-        const detectorFlex5 = new StallDetector(stateManager2, {
-            caution_level: 2,
-            stall_flexibility: 5,
-            communication_directness: 3,
-            proactivity_level: 2,
-        });
-        // immediate base N=6 → adjusted N=round(6*2.0)=12 → need 13 entries
-        // 7 flat entries: not enough data → null
-        const shortHistory = makeGapHistory(new Array(7).fill(0.5));
-        expect(detectorFlex5.checkDimensionStall("g", "d", shortHistory, "immediate")).toBeNull();
-        // 13 flat entries: stall detected
-        const longHistory = makeGapHistory(new Array(13).fill(0.5));
-        expect(detectorFlex5.checkDimensionStall("g", "d", longHistory, "immediate")).not.toBeNull();
-    });
-    it("stall_flexibility=5 → long_term N=20 (need 21 entries)", () => {
-        const detectorFlex5 = new StallDetector(stateManager2, {
-            caution_level: 2,
-            stall_flexibility: 5,
-            communication_directness: 3,
-            proactivity_level: 2,
-        });
-        // long_term base N=10 → adjusted N=round(10*2.0)=20 → need 21 entries
-        // 11 flat entries: not enough data → null
-        const shortHistory = makeGapHistory(new Array(11).fill(0.5));
-        expect(detectorFlex5.checkDimensionStall("g", "d", shortHistory, "long_term")).toBeNull();
-        // 21 flat entries: stall detected
-        const longHistory = makeGapHistory(new Array(21).fill(0.5));
-        expect(detectorFlex5.checkDimensionStall("g", "d", longHistory, "long_term")).not.toBeNull();
-    });
-    it("CONSECUTIVE_FAILURE_THRESHOLD is unchanged at stall_flexibility=1 (threshold=3)", () => {
-        const detectorFlex1 = new StallDetector(stateManager2, {
-            caution_level: 2,
-            stall_flexibility: 1,
-            communication_directness: 3,
-            proactivity_level: 2,
-        });
-        expect(detectorFlex1.checkConsecutiveFailures("g", "d", 2)).toBeNull();
-        expect(detectorFlex1.checkConsecutiveFailures("g", "d", 3)).not.toBeNull();
-    });
-    it("CONSECUTIVE_FAILURE_THRESHOLD is unchanged at stall_flexibility=5 (threshold still=3)", () => {
-        const detectorFlex5 = new StallDetector(stateManager2, {
-            caution_level: 2,
-            stall_flexibility: 5,
-            communication_directness: 3,
-            proactivity_level: 2,
-        });
-        expect(detectorFlex5.checkConsecutiveFailures("g", "d", 2)).toBeNull();
-        expect(detectorFlex5.checkConsecutiveFailures("g", "d", 3)).not.toBeNull();
-    });
-    it("ESCALATION_CAP is unchanged at any stall_flexibility (caps at 3)", async () => {
-        const detectorFlex5 = new StallDetector(stateManager2, {
-            caution_level: 2,
-            stall_flexibility: 5,
-            communication_directness: 3,
-            proactivity_level: 2,
-        });
-        await detectorFlex5.incrementEscalation("g", "d");
-        await detectorFlex5.incrementEscalation("g", "d");
-        await detectorFlex5.incrementEscalation("g", "d");
-        const capped = await detectorFlex5.incrementEscalation("g", "d");
-        expect(capped).toBe(3);
-    });
-    it("stall_flexibility=3 → multiplier=1.5 → medium_term N=round(5*1.5)=8", () => {
-        const detectorFlex3 = new StallDetector(stateManager2, {
-            caution_level: 2,
-            stall_flexibility: 3,
-            communication_directness: 3,
-            proactivity_level: 2,
-        });
-        // medium_term base N=5 → adjusted N=round(5*1.5)=8 → need 9 entries
-        // 6 flat entries: not enough → null
-        const shortHistory = makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.5]);
-        expect(detectorFlex3.checkDimensionStall("g", "d", shortHistory, "medium_term")).toBeNull();
-        // 9 flat entries: stall detected
-        const longHistory = makeGapHistory(new Array(9).fill(0.5));
-        expect(detectorFlex3.checkDimensionStall("g", "d", longHistory, "medium_term")).not.toBeNull();
-    });
-    it("constructor with explicit DEFAULT values identical to omitting characterConfig", () => {
-        const detectorDefault = new StallDetector(stateManager2);
-        const detectorExplicit = new StallDetector(stateManager2, {
-            caution_level: 2,
-            stall_flexibility: 1,
-            communication_directness: 3,
-            proactivity_level: 2,
-        });
-        // Both should behave identically for immediate stall (N=6, need 7 entries)
-        const history = makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]);
-        const r1 = detectorDefault.checkDimensionStall("g", "d", history, "immediate");
-        const r2 = detectorExplicit.checkDimensionStall("g", "d", history, "immediate");
-        expect(r1).not.toBeNull();
-        expect(r2).not.toBeNull();
-        expect(r1.stall_type).toBe(r2.stall_type);
-    });
-});
-// ─── Zero-progress early detection ───
-describe("zero-progress early detection", () => {
-    it("detects zero-progress stall with sufficient history at gap=1.00", () => {
-        const history = makeGapHistory([1.0, 1.0, 1.0, 1.0, 1.0, 1.0]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("dimension_stall");
-        expect(result.goal_id).toBe("goal-1");
-        expect(result.dimension_name).toBe("dim-a");
-        expect(result.decay_factor).toBe(0.6);
-    });
-    it("detects zero-progress in checkGlobalStall with sufficient history", () => {
-        const dims = new Map([
-            ["dim-a", makeGapHistory([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])],
-        ]);
-        const result = detector.checkGlobalStall("goal-1", dims);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("global_stall");
-        expect(result.goal_id).toBe("goal-1");
-    });
-    it("does NOT trigger zero-progress when gap is below floor with insufficient history", () => {
-        const history = makeGapHistory([0.89, 0.89, 0.89]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history);
-        expect(result).toBeNull(); // insufficient history (3 < 6) and below GAP_FLOOR
-    });
-    it("does NOT trigger zero-progress when gap values vary too much", () => {
-        // oldest=1.0, latest=0.9, diff=0.1 >= 0.05 → improvement detected → null
-        const history = makeGapHistory([1.0, 0.9, 1.0, 0.9, 1.0, 0.9]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history);
-        expect(result).toBeNull();
-    });
-    it("detects zero-progress at gap=0.98 (near but not exactly 1.00)", () => {
-        const history = makeGapHistory([0.98, 0.98, 0.98, 0.98, 0.98, 0.98]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("dimension_stall");
-    });
-    it("does NOT trigger global stall when one dimension is zero-progress but another is improving", () => {
-        // dim-a: stuck at 1.0, dim-b: improving from 1.0 to 0.5
-        const dims = new Map([
-            ["dim-a", makeGapHistory([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])],
-            ["dim-b", makeGapHistory([1.0, 0.9, 0.8, 0.7, 0.6, 0.5])],
-        ]);
-        const result = detector.checkGlobalStall("goal-1", dims);
-        expect(result).toBeNull(); // dim-b improved, so no global stall
-    });
-    it("triggers global stall when ALL dimensions are zero-progress", () => {
-        const dims = new Map([
-            ["dim-a", makeGapHistory([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])],
-            ["dim-b", makeGapHistory([0.95, 0.95, 0.95, 0.95, 0.95, 0.95])],
-        ]);
-        const result = detector.checkGlobalStall("goal-1", dims);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("global_stall");
-    });
-    it("detects zero-progress at gap=0.90 after GAP_FLOOR lowered", () => {
-        const history = makeGapHistory([0.90, 0.90, 0.90, 0.90, 0.90, 0.90]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("dimension_stall");
-    });
-});
-// ─── Achieved-dimension guard (ACHIEVED_GAP_THRESHOLD) ───
-describe("achieved-dimension guard", () => {
-    // checkDimensionStall tests
-    it("returns null when full window is at or below achieved threshold (0.02)", () => {
-        // All 6 entries <= 0.02 → dimension is achieved → not a stall
-        const history = makeGapHistory([0.02, 0.01, 0.01, 0.02, 0.00, 0.01]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history);
-        expect(result).toBeNull();
-    });
-    it("returns null when full window is exactly at threshold (0.02)", () => {
-        // Boundary: exactly 0.02 for all entries → achieved
-        const history = makeGapHistory([0.02, 0.02, 0.02, 0.02, 0.02, 0.02]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history);
-        expect(result).toBeNull();
-    });
-    it("does NOT skip when dimension is just above threshold (0.03 > 0.02)", () => {
-        // Latest is 0.03 — just above threshold; still checked for stall
-        const history = makeGapHistory([0.03, 0.03, 0.03, 0.03, 0.03, 0.03]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("dimension_stall");
-    });
-    it("does NOT skip when oscillating around threshold (some above, some below)", () => {
-        // Entries alternate between 0.01 (below) and 0.05 (above) — not all achieved
-        const history = makeGapHistory([0.01, 0.05, 0.01, 0.05, 0.01, 0.05]);
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history);
-        // Not all below threshold, so guard does not fire — check for stall normally
-        // oldest=0.01, latest=0.05 → no improvement → stall
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("dimension_stall");
-    });
-    it("does NOT skip when only the latest entry is below threshold", () => {
-        // Only last entry is 0.01; earlier entries are 0.50 — not full-window achieved
-        const history = makeGapHistory([0.50, 0.50, 0.50, 0.50, 0.50, 0.01]);
-        // oldest=0.50, latest=0.01 → improvement of 0.49 >= MIN_IMPROVEMENT_DELTA → null (improving)
-        const result = detector.checkDimensionStall("goal-1", "dim-a", history);
-        expect(result).toBeNull(); // null because of meaningful improvement, not achieved guard
-    });
-    // checkGlobalStall tests
-    it("checkGlobalStall: returns null when all dimensions are achieved", () => {
-        // Both dimensions have all-window gaps <= 0.02 → both achieved → no global stall
-        const dims = new Map([
-            ["dim-a", makeGapHistory([0.01, 0.01, 0.01, 0.01, 0.01, 0.01])],
-            ["dim-b", makeGapHistory([0.02, 0.02, 0.02, 0.02, 0.02, 0.02])],
-        ]);
-        const result = detector.checkGlobalStall("goal-1", dims);
-        expect(result).toBeNull();
-    });
-    it("checkGlobalStall: returns null when one dim achieved, one improving", () => {
-        // dim-a achieved, dim-b improving — no global stall
-        const dims = new Map([
-            ["dim-a", makeGapHistory([0.01, 0.01, 0.01, 0.01, 0.01, 0.01])],
-            ["dim-b", makeGapHistory([0.50, 0.45, 0.40, 0.35, 0.30, 0.20])], // improving by 0.30
-        ]);
-        const result = detector.checkGlobalStall("goal-1", dims);
-        expect(result).toBeNull();
-    });
-    it("checkGlobalStall: returns global_stall when one dim achieved, one flat (non-achieved)", () => {
-        // dim-a achieved; dim-b flat at 0.5 → non-achieved, non-improving → global stall
-        const dims = new Map([
-            ["dim-a", makeGapHistory([0.01, 0.01, 0.01, 0.01, 0.01, 0.01])],
-            ["dim-b", makeGapHistory([0.50, 0.50, 0.50, 0.50, 0.50, 0.50])],
-        ]);
-        const result = detector.checkGlobalStall("goal-1", dims);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("global_stall");
-        expect(result.suggested_cause).toBe("goal_infeasible");
-    });
-});
-// ─── ProgressPredictor integration ───
-describe("StallDetector with ProgressPredictor", () => {
-    let sm;
-    let tmpDir;
-    beforeEach(() => {
-        tmpDir = makeTempDir();
-        sm = new StateManager(tmpDir);
-    });
-    afterEach(() => {
-        fs.rmSync(tmpDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-    });
-    it("works as before (no predictor) — no regression for normal stall detection", () => {
-        const det = new StallDetector(sm);
-        // Flat history → normal stall
-        const history = makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.5]);
-        const result = det.checkDimensionStall("g1", "d1", history);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("dimension_stall");
-    });
-    it("works as before (no predictor) — no false predicted stall on improving series", () => {
-        const det = new StallDetector(sm);
-        const history = makeGapHistory([0.8, 0.7, 0.6, 0.5, 0.4, 0.3]);
-        const result = det.checkDimensionStall("g1", "d1", history);
-        expect(result).toBeNull();
-    });
-    it("detects predicted_plateau when predictor says stable and confidence > 0.6", () => {
-        const predictor = new ProgressPredictor();
-        const det = new StallDetector(sm, undefined, predictor);
-        // History: early improvement (oldest=0.8, latest=0.4 → diff=0.4 >= 0.05) so it
-        // passes the improvement check and goes to the predictor.
-        // Last 5 entries: [0.4, 0.4, 0.4, 0.4, 0.4] → slope=0, stable, R²=1.0 (confidence=1.0)
-        const history = makeGapHistory([0.8, 0.4, 0.4, 0.4, 0.4, 0.4]);
-        const result = det.checkDimensionStall("g1", "d1", history);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("predicted_plateau");
-        expect(result.goal_id).toBe("g1");
-        expect(result.dimension_name).toBe("d1");
-    });
-    it("detects predicted_regression when predictor says worsening and confidence > 0.6", () => {
-        const predictor = new ProgressPredictor();
-        const det = new StallDetector(sm, undefined, predictor);
-        // History starts improving (oldest-latest >= 0.05) but recent tail is increasing
-        // History: 0.8, 0.3, 0.4, 0.5, 0.6, 0.7 — oldest=0.8, latest=0.7, diff=0.1 >= 0.05
-        // Last 5: [0.3, 0.4, 0.5, 0.6, 0.7] — slope = +0.1 (worsening), R² = 1.0
-        const history = makeGapHistory([0.8, 0.3, 0.4, 0.5, 0.6, 0.7]);
-        const result = det.checkDimensionStall("g1", "d1", history);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("predicted_regression");
-        expect(result.goal_id).toBe("g1");
-        expect(result.dimension_name).toBe("d1");
-    });
-    it("does NOT trigger predicted stall when confidence <= 0.6 (noisy data)", () => {
-        const predictor = new ProgressPredictor();
-        const det = new StallDetector(sm, undefined, predictor);
-        // Improving overall (oldest-latest >= 0.05) but noisy trend — R² will be low
-        // Use large but noisy improvement so predictor confidence is low
-        const history = makeGapHistory([0.9, 0.2, 0.9, 0.2, 0.9, 0.3]);
-        const result = det.checkDimensionStall("g1", "d1", history);
-        // oldest=0.9, latest=0.3 → improvement=0.6 >= 0.05 → goes to predictor
-        // noisy last 5: [0.2, 0.9, 0.2, 0.9, 0.3] → R² ≈ 0 → no predicted stall
-        expect(result).toBeNull();
-    });
-    it("normal stall (dimension_stall) takes priority over predictor check", () => {
-        const predictor = new ProgressPredictor();
-        const det = new StallDetector(sm, undefined, predictor);
-        // Flat history → falls through to normal dimension_stall, predictor never fires
-        const history = makeGapHistory([0.5, 0.5, 0.5, 0.5, 0.5, 0.5]);
-        const result = det.checkDimensionStall("g1", "d1", history);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("dimension_stall"); // not predicted_plateau
-    });
-    it("returns null when predictor says improving (trend=improving, confidence > 0.6)", () => {
-        const predictor = new ProgressPredictor();
-        const det = new StallDetector(sm, undefined, predictor);
-        // History: oldest=0.8, latest=0.3 → diff=0.5 >= 0.05 → passes improvement check, goes to predictor.
-        // Last 5: [0.7, 0.6, 0.5, 0.4, 0.3] — monotonically decreasing → slope = -0.1 (improving)
-        // trend="improving" → checkPredictedStall returns null at line 564
-        const history = makeGapHistory([0.8, 0.7, 0.6, 0.5, 0.4, 0.3]);
-        const result = det.checkDimensionStall("g1", "d1", history);
-        expect(result).toBeNull();
-    });
-});
-// ─── durationToHours: weeks and default fallback ───
-describe("checkTimeExceeded — additional duration units", () => {
-    it("handles duration in weeks correctly (estimate × 2)", () => {
-        // Estimate = 1 week (168 hours) → threshold = 336 hours; started 400 hours ago → stall
-        const startedAt = new Date(Date.now() - 400 * 60 * 60 * 1000).toISOString();
-        const task = {
-            goal_id: "goal-1",
-            started_at: startedAt,
-            estimated_duration: { value: 1, unit: "weeks" },
-        };
-        const result = detector.checkTimeExceeded(task);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("time_exceeded");
-    });
-    it("does not stall when within 2-week threshold (1 week estimate, 1 week elapsed)", () => {
-        // Estimate = 1 week (168h) → threshold = 336h; started 100 hours ago → within threshold
-        const startedAt = new Date(Date.now() - 100 * 60 * 60 * 1000).toISOString();
-        const task = {
-            goal_id: "goal-1",
-            started_at: startedAt,
-            estimated_duration: { value: 1, unit: "weeks" },
-        };
-        expect(detector.checkTimeExceeded(task)).toBeNull();
-    });
-    it("handles unknown duration unit (default fallback treats value as hours)", () => {
-        // Unknown unit → value treated as hours; value=1 hour → threshold = 2 hours
-        // started 3 hours ago → exceeds threshold
-        const startedAt = new Date(Date.now() - 3 * 60 * 60 * 1000).toISOString();
-        const task = {
-            goal_id: "goal-1",
-            started_at: startedAt,
-            estimated_duration: { value: 1, unit: "fortnights" }, // unknown unit
-        };
-        const result = detector.checkTimeExceeded(task);
-        expect(result).not.toBeNull();
-        expect(result.stall_type).toBe("time_exceeded");
-    });
-    it("does not stall for unknown unit when within fallback threshold", () => {
-        // Unknown unit → value=10 hours → threshold = 20 hours; started 5 hours ago → ok
-        const startedAt = new Date(Date.now() - 5 * 60 * 60 * 1000).toISOString();
-        const task = {
-            goal_id: "goal-1",
-            started_at: startedAt,
-            estimated_duration: { value: 10, unit: "fortnights" },
-        };
-        expect(detector.checkTimeExceeded(task)).toBeNull();
-    });
-});
-//# sourceMappingURL=stall-detector.test.js.map