pulseed 0.1.5 → 0.2.0

package/dist/goal/__tests__/state-aggregator.test.js

@@ -0,0 +1,840 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import { StateManager } from "../../base/state/state-manager.js";
+import { SatisficingJudge } from "../../drive/satisficing-judge.js";
+import { StateAggregator } from "../state-aggregator.js";
+import { makeTempDir } from "../../../tests/helpers/temp-dir.js";
+import { makeGoal } from "../../../tests/helpers/fixtures.js";
+function makeDimension(overrides = {}) {
+    return {
+        name: "score",
+        label: "Score",
+        current_value: 50,
+        threshold: { type: "min", value: 100 },
+        confidence: 0.9,
+        observation_method: {
+            type: "mechanical",
+            source: "test",
+            schedule: null,
+            endpoint: null,
+            confidence_tier: "mechanical",
+        },
+        last_updated: new Date().toISOString(),
+        history: [],
+        weight: 1.0,
+        uncertainty_weight: null,
+        state_integrity: "ok",
+        dimension_mapping: null,
+        ...overrides,
+    };
+}
+/** Create an ISO timestamp offset from now by the given number of hours */
+function hoursFromNow(hours) {
+    return new Date(Date.now() + hours * 3600 * 1000).toISOString();
+}
+// ─── Test Setup ───
+let tempDir;
+let stateManager;
+let judge;
+let aggregator;
+beforeEach(() => {
+    tempDir = makeTempDir();
+    stateManager = new StateManager(tempDir);
+    judge = new SatisficingJudge(stateManager);
+    aggregator = new StateAggregator(stateManager, judge);
+});
+afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+});
+// ─── Helper: build a parent with N children ───
+async function buildTree(numChildren, childOverrides = []) {
+    const children = Array.from({ length: numChildren }, (_, i) => {
+        const overrides = childOverrides[i] ?? {};
+        return makeGoal({ id: `child-${i}`, ...overrides });
+    });
+    const parent = makeGoal({
+        id: "parent",
+        children_ids: children.map((c) => c.id),
+    });
+    for (const child of children) {
+        await stateManager.saveGoal({ ...child, parent_id: parent.id });
+    }
+    await stateManager.saveGoal(parent);
+    return { parent, children };
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// 1. Min aggregation
+// ═══════════════════════════════════════════════════════════════════════════
+describe("aggregateChildStates — min aggregation (default)", async () => {
+    it("picks the worst (largest) child gap — single dominant child", async () => {
+        await buildTree(3, [
+            { dimensions: [makeDimension({ current_value: 90 })] }, // gap ~0.10
+            { dimensions: [makeDimension({ current_value: 0 })] }, // gap = 1.0
+            { dimensions: [makeDimension({ current_value: 80 })] }, // gap ~0.20
+        ]);
+        const result = await aggregator.aggregateChildStates("parent");
+        // "min" on gaps = smallest gap, which corresponds to the BEST child
+        // (closest to threshold). The worst child has gap 1.0, but min gives 0.10.
+        expect(result.aggregation_method).toBe("min");
+        expect(result.aggregated_gap).toBeCloseTo(0.1, 1);
+    });
+    it("returns 0 when all children are completed", async () => {
+        await buildTree(2, [
+            { status: "completed", dimensions: [] },
+            { status: "completed", dimensions: [] },
+        ]);
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_gap).toBe(0);
+    });
+    it("returns 0 when all children have gap 0", async () => {
+        await buildTree(2, [
+            { dimensions: [makeDimension({ current_value: 100 })] },
+            { dimensions: [makeDimension({ current_value: 100 })] },
+        ]);
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_gap).toBe(0);
+    });
+    it("returns same gap when all children have identical gap", async () => {
+        await buildTree(3, [
+            { dimensions: [makeDimension({ current_value: 50 })] },
+            { dimensions: [makeDimension({ current_value: 50 })] },
+            { dimensions: [makeDimension({ current_value: 50 })] },
+        ]);
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_gap).toBeCloseTo(0.5, 5);
+    });
+    it("tracks per-child gaps in child_gaps map", async () => {
+        await buildTree(2, [
+            { dimensions: [makeDimension({ current_value: 100 })] }, // gap 0
+            { dimensions: [makeDimension({ current_value: 0 })] }, // gap 1
+        ]);
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.child_gaps["child-0"]).toBeCloseTo(0, 5);
+        expect(result.child_gaps["child-1"]).toBeCloseTo(1.0, 5);
+    });
+    it("tracks per-child completion status", async () => {
+        await buildTree(2, [
+            { status: "completed" },
+            { status: "active" },
+        ]);
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.child_completions["child-0"]).toBe(true);
+        expect(result.child_completions["child-1"]).toBe(false);
+    });
+    it("returns aggregated_gap = 0 when parent has no children", async () => {
+        const parent = makeGoal({ id: "empty-parent", children_ids: [] });
+        await stateManager.saveGoal(parent);
+        const result = await aggregator.aggregateChildStates("empty-parent");
+        expect(result.aggregated_gap).toBe(0);
+    });
+    it("handles one child with very high gap (1.0)", async () => {
+        await buildTree(2, [
+            { dimensions: [makeDimension({ current_value: 99 })] }, // gap 0.01
+            { dimensions: [makeDimension({ current_value: 0 })] }, // gap 1.0
+        ]);
+        const result = await aggregator.aggregateChildStates("parent");
+        // min picks the best child (gap 0.01)
+        expect(result.aggregated_gap).toBeCloseTo(0.01, 2);
+    });
+    it("throws when parent goal not found", async () => {
+        await expect(aggregator.aggregateChildStates("nonexistent-parent")).rejects.toThrow(/not found/);
+    });
+});
+// ═══════════════════════════════════════════════════════════════════════════
+// 2. Avg aggregation
+// ═══════════════════════════════════════════════════════════════════════════
+describe("aggregateChildStates — avg aggregation", () => {
+    function setAvgRule() {
+        const rule = {
+            parent_id: "parent",
+            child_ids: ["child-0", "child-1"],
+            aggregation: "avg",
+            propagation_direction: "up",
+        };
+        aggregator.registerAggregationRule(rule);
+    }
+    it("averages child gaps", async () => {
+        await buildTree(2, [
+            { dimensions: [makeDimension({ current_value: 0 })] }, // gap 1.0
+            { dimensions: [makeDimension({ current_value: 100 })] }, // gap 0.0
+        ]);
+        setAvgRule();
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregation_method).toBe("avg");
+        expect(result.aggregated_gap).toBeCloseTo(0.5, 5);
+    });
+    it("avg with 3 equal children", async () => {
+        await buildTree(3, [
+            { dimensions: [makeDimension({ current_value: 50 })] },
+            { dimensions: [makeDimension({ current_value: 50 })] },
+            { dimensions: [makeDimension({ current_value: 50 })] },
+        ]);
+        aggregator.registerAggregationRule({
+            parent_id: "parent",
+            child_ids: ["child-0", "child-1", "child-2"],
+            aggregation: "avg",
+            propagation_direction: "up",
+        });
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_gap).toBeCloseTo(0.5, 5);
+    });
+    it("avg of 0.25 and 0.75 gives 0.5", async () => {
+        await buildTree(2, [
+            { dimensions: [makeDimension({ current_value: 75 })] }, // gap 0.25
+            { dimensions: [makeDimension({ current_value: 25 })] }, // gap 0.75
+        ]);
+        setAvgRule();
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_gap).toBeCloseTo(0.5, 2);
+    });
+    it("avg with single child equals that child gap", async () => {
+        await buildTree(1, [{ dimensions: [makeDimension({ current_value: 60 })] }]);
+        aggregator.registerAggregationRule({
+            parent_id: "parent",
+            child_ids: ["child-0"],
+            aggregation: "avg",
+            propagation_direction: "up",
+        });
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_gap).toBeCloseTo(0.4, 2);
+    });
+    it("avg includes completed children as gap 0", async () => {
+        await buildTree(2, [
+            { status: "completed", dimensions: [] },
+            { dimensions: [makeDimension({ current_value: 0 })] }, // gap 1.0
+        ]);
+        setAvgRule();
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_gap).toBeCloseTo(0.5, 5);
+    });
+    it("avg returns 0 when all children complete", async () => {
+        await buildTree(2, [
+            { status: "completed", dimensions: [] },
+            { status: "completed", dimensions: [] },
+        ]);
+        setAvgRule();
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_gap).toBe(0);
+    });
+});
+// ═══════════════════════════════════════════════════════════════════════════
+// 3. Max aggregation
+// ═══════════════════════════════════════════════════════════════════════════
+describe("aggregateChildStates — max aggregation", () => {
+    function setMaxRule() {
+        aggregator.registerAggregationRule({
+            parent_id: "parent",
+            child_ids: ["child-0", "child-1"],
+            aggregation: "max",
+            propagation_direction: "up",
+        });
+    }
+    it("picks the largest child gap (worst child)", async () => {
+        await buildTree(2, [
+            { dimensions: [makeDimension({ current_value: 90 })] }, // gap 0.10
+            { dimensions: [makeDimension({ current_value: 0 })] }, // gap 1.0
+        ]);
+        setMaxRule();
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregation_method).toBe("max");
+        expect(result.aggregated_gap).toBeCloseTo(1.0, 5);
+    });
+    it("returns 0 when all children gap is 0", async () => {
+        await buildTree(2, [
+            { dimensions: [makeDimension({ current_value: 100 })] },
+            { dimensions: [makeDimension({ current_value: 100 })] },
+        ]);
+        setMaxRule();
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_gap).toBe(0);
+    });
+    it("max gap with 3 children picks worst", async () => {
+        await buildTree(3, [
+            { dimensions: [makeDimension({ current_value: 100 })] }, // 0
+            { dimensions: [makeDimension({ current_value: 50 })] }, // 0.5
+            { dimensions: [makeDimension({ current_value: 80 })] }, // 0.2
+        ]);
+        aggregator.registerAggregationRule({
+            parent_id: "parent",
+            child_ids: ["child-0", "child-1", "child-2"],
+            aggregation: "max",
+            propagation_direction: "up",
+        });
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_gap).toBeCloseTo(0.5, 2);
+    });
+    it("max with single child equals that child gap", async () => {
+        await buildTree(1, [{ dimensions: [makeDimension({ current_value: 40 })] }]);
+        aggregator.registerAggregationRule({
+            parent_id: "parent",
+            child_ids: ["child-0"],
+            aggregation: "max",
+            propagation_direction: "up",
+        });
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_gap).toBeCloseTo(0.6, 2);
+    });
+});
+// ═══════════════════════════════════════════════════════════════════════════
+// 4. All_required aggregation
+// ═══════════════════════════════════════════════════════════════════════════
+describe("aggregateChildStates — all_required aggregation", async () => {
+    function setAllRequiredRule(childIds) {
+        aggregator.registerAggregationRule({
+            parent_id: "parent",
+            child_ids: childIds ?? ["child-0", "child-1"],
+            aggregation: "all_required",
+            propagation_direction: "up",
+        });
+    }
+    it("returns non-zero gap when any child is incomplete", async () => {
+        await buildTree(2, [
+            { status: "completed", dimensions: [] }, // done
+            { dimensions: [makeDimension({ current_value: 0 })] }, // gap 1.0
+        ]);
+        setAllRequiredRule();
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregation_method).toBe("all_required");
+        expect(result.aggregated_gap).toBeGreaterThan(0);
+    });
+    it("returns 0 gap when all children are complete", async () => {
+        await buildTree(2, [
+            { status: "completed", dimensions: [] },
+            { status: "completed", dimensions: [] },
+        ]);
+        setAllRequiredRule();
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_gap).toBe(0);
+    });
+    it("partial completion still blocks parent", async () => {
+        await buildTree(3, [
+            { status: "completed", dimensions: [] },
+            { status: "completed", dimensions: [] },
+            { dimensions: [makeDimension({ current_value: 50 })] }, // still active
+        ]);
+        setAllRequiredRule(["child-0", "child-1", "child-2"]);
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_gap).toBeGreaterThan(0);
+    });
+    it("single incomplete child with full gap", async () => {
+        await buildTree(1, [{ dimensions: [makeDimension({ current_value: 0 })] }]);
+        aggregator.registerAggregationRule({
+            parent_id: "parent",
+            child_ids: ["child-0"],
+            aggregation: "all_required",
+            propagation_direction: "up",
+        });
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_gap).toBeGreaterThan(0);
+    });
+    it("returns 0 when parent has no children", async () => {
+        const parent = makeGoal({ id: "empty" });
+        await stateManager.saveGoal(parent);
+        aggregator.registerAggregationRule({
+            parent_id: "empty",
+            child_ids: [],
+            aggregation: "all_required",
+            propagation_direction: "up",
+        });
+        const result = await aggregator.aggregateChildStates("empty");
+        expect(result.aggregated_gap).toBe(0);
+    });
+    it("cancelled child counts as done", async () => {
+        await buildTree(2, [
+            { status: "cancelled", dimensions: [] },
+            { status: "completed", dimensions: [] },
+        ]);
+        setAllRequiredRule();
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_gap).toBe(0);
+    });
+});
+// ═══════════════════════════════════════════════════════════════════════════
+// 5. Confidence propagation
+// ═══════════════════════════════════════════════════════════════════════════
+describe("aggregateChildStates — confidence propagation", async () => {
+    it("aggregated confidence is min of all child confidences", async () => {
+        await buildTree(3, [
+            { dimensions: [makeDimension({ confidence: 0.9 })] },
+            { dimensions: [makeDimension({ confidence: 0.6 })] },
+            { dimensions: [makeDimension({ confidence: 0.8 })] },
+        ]);
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_confidence).toBeCloseTo(0.6, 5);
+    });
+    it("single child confidence equals that child's confidence", async () => {
+        await buildTree(1, [{ dimensions: [makeDimension({ confidence: 0.72 })] }]);
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_confidence).toBeCloseTo(0.72, 5);
+    });
+    it("high confidence across all children gives high aggregated confidence", async () => {
+        await buildTree(3, [
+            { dimensions: [makeDimension({ confidence: 0.95 })] },
+            { dimensions: [makeDimension({ confidence: 0.90 })] },
+            { dimensions: [makeDimension({ confidence: 0.88 })] },
+        ]);
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_confidence).toBeCloseTo(0.88, 5);
+    });
+    it("one very low confidence child drives the aggregate down", async () => {
+        await buildTree(3, [
+            { dimensions: [makeDimension({ confidence: 0.95 })] },
+            { dimensions: [makeDimension({ confidence: 0.95 })] },
+            { dimensions: [makeDimension({ confidence: 0.1 })] },
+        ]);
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_confidence).toBeCloseTo(0.1, 5);
+    });
+    it("missing child sets its confidence contribution to 0", async () => {
+        const parent = makeGoal({
+            id: "parent-missing",
+            children_ids: ["real-child", "ghost-child"],
+        });
+        const realChild = makeGoal({
+            id: "real-child",
+            parent_id: "parent-missing",
+            dimensions: [makeDimension({ confidence: 0.9 })],
+        });
+        await stateManager.saveGoal(parent);
+        await stateManager.saveGoal(realChild);
+        const result = await aggregator.aggregateChildStates("parent-missing");
+        expect(result.aggregated_confidence).toBe(0);
+    });
+    it("no children returns confidence 1.0", async () => {
+        const parent = makeGoal({ id: "no-children-conf", children_ids: [] });
+        await stateManager.saveGoal(parent);
+        const result = await aggregator.aggregateChildStates("no-children-conf");
+        expect(result.aggregated_confidence).toBe(1.0);
+    });
+});
+// ═══════════════════════════════════════════════════════════════════════════
+// 6. Downward constraint propagation
+// ═══════════════════════════════════════════════════════════════════════════
+describe("propagateStateDown — constraint propagation", async () => {
+    it("new parent constraint is appended to child", async () => {
+        const child = makeGoal({
+            id: "child",
+            parent_id: "parent",
+            constraints: ["existing"],
+        });
+        const parent = makeGoal({
+            id: "parent",
+            children_ids: ["child"],
+            constraints: ["existing", "new-constraint"],
+        });
+        await stateManager.saveGoal(child);
+        await stateManager.saveGoal(parent);
+        await aggregator.propagateStateDown("parent");
+        const updatedChild = (await stateManager.loadGoal("child"));
+        expect(updatedChild.constraints).toContain("new-constraint");
+        expect(updatedChild.constraints).toContain("existing");
+    });
+    it("does not duplicate an existing constraint (idempotent)", async () => {
+        const child = makeGoal({
+            id: "child",
+            parent_id: "parent",
+            constraints: ["shared"],
+        });
+        const parent = makeGoal({
+            id: "parent",
+            children_ids: ["child"],
+            constraints: ["shared"],
+        });
+        await stateManager.saveGoal(child);
+        await stateManager.saveGoal(parent);
+        await aggregator.propagateStateDown("parent");
+        const updatedChild = (await stateManager.loadGoal("child"));
+        const occurrences = updatedChild.constraints.filter((c) => c === "shared");
+        expect(occurrences).toHaveLength(1);
+    });
+    it("propagates multiple new constraints at once", async () => {
+        const child = makeGoal({ id: "child", parent_id: "parent" });
+        const parent = makeGoal({
+            id: "parent",
+            children_ids: ["child"],
+            constraints: ["c1", "c2", "c3"],
+        });
+        await stateManager.saveGoal(child);
+        await stateManager.saveGoal(parent);
+        await aggregator.propagateStateDown("parent");
+        const updatedChild = (await stateManager.loadGoal("child"));
+        expect(updatedChild.constraints).toEqual(expect.arrayContaining(["c1", "c2", "c3"]));
+    });
+    it("propagates to multiple children", async () => {
+        const c1 = makeGoal({ id: "c1", parent_id: "parent" });
+        const c2 = makeGoal({ id: "c2", parent_id: "parent" });
+        const parent = makeGoal({
+            id: "parent",
+            children_ids: ["c1", "c2"],
+            constraints: ["budget-limit"],
+        });
+        await stateManager.saveGoal(c1);
+        await stateManager.saveGoal(c2);
+        await stateManager.saveGoal(parent);
+        await aggregator.propagateStateDown("parent");
+        expect((await stateManager.loadGoal("c1")).constraints).toContain("budget-limit");
+        expect((await stateManager.loadGoal("c2")).constraints).toContain("budget-limit");
+    });
+    it("is idempotent across multiple propagation calls", async () => {
+        const child = makeGoal({ id: "child", parent_id: "parent" });
+        const parent = makeGoal({
+            id: "parent",
+            children_ids: ["child"],
+            constraints: ["once"],
+        });
+        await stateManager.saveGoal(child);
+        await stateManager.saveGoal(parent);
+        await aggregator.propagateStateDown("parent");
+        await aggregator.propagateStateDown("parent");
+        await aggregator.propagateStateDown("parent");
+        const updatedChild = (await stateManager.loadGoal("child"));
+        const count = updatedChild.constraints.filter((c) => c === "once").length;
+        expect(count).toBe(1);
+    });
+    it("throws when parent goal not found", async () => {
+        await expect(aggregator.propagateStateDown("ghost-parent")).rejects.toThrow(/not found/);
+    });
+});
+// ═══════════════════════════════════════════════════════════════════════════
+// 7. Downward deadline adjustment
+// ═══════════════════════════════════════════════════════════════════════════
+describe("propagateStateDown — deadline adjustment", async () => {
+    it("child deadline is not later than parent deadline", async () => {
+        const childDeadline = hoursFromNow(48);
+        const parentDeadline = hoursFromNow(24); // shorter than child
+        const child = makeGoal({
+            id: "child",
+            parent_id: "parent",
+            deadline: childDeadline,
+        });
+        const parent = makeGoal({
+            id: "parent",
+            children_ids: ["child"],
+            deadline: parentDeadline,
+        });
+        await stateManager.saveGoal(child);
+        await stateManager.saveGoal(parent);
+        await aggregator.propagateStateDown("parent");
+        const updated = (await stateManager.loadGoal("child"));
+        const updatedMs = Date.parse(updated.deadline);
+        const parentMs = Date.parse(parentDeadline);
+        expect(updatedMs).toBeLessThanOrEqual(parentMs);
+    });
+    it("child deadline is not changed when it is already within parent window", async () => {
+        const childDeadline = hoursFromNow(12);
+        const parentDeadline = hoursFromNow(24); // parent is later
+        const child = makeGoal({
+            id: "child",
+            parent_id: "parent",
+            deadline: childDeadline,
+        });
+        const parent = makeGoal({
+            id: "parent",
+            children_ids: ["child"],
+            deadline: parentDeadline,
+        });
+        await stateManager.saveGoal(child);
+        await stateManager.saveGoal(parent);
+        await aggregator.propagateStateDown("parent");
+        const updated = (await stateManager.loadGoal("child"));
+        // child already within parent window — deadline should stay the same
+        expect(updated.deadline).toBe(childDeadline);
+    });
+    it("child with null deadline is not affected by parent deadline", async () => {
+        const child = makeGoal({
+            id: "child",
+            parent_id: "parent",
+            deadline: null,
+        });
+        const parent = makeGoal({
+            id: "parent",
+            children_ids: ["child"],
+            deadline: hoursFromNow(10),
+        });
+        await stateManager.saveGoal(child);
+        await stateManager.saveGoal(parent);
+        await aggregator.propagateStateDown("parent");
+        const updated = (await stateManager.loadGoal("child"));
+        expect(updated.deadline).toBeNull();
+    });
+    it("no deadline propagation when parent has no deadline", async () => {
+        const childDeadline = hoursFromNow(24);
+        const child = makeGoal({
+            id: "child",
+            parent_id: "parent",
+            deadline: childDeadline,
+        });
+        const parent = makeGoal({
+            id: "parent",
+            children_ids: ["child"],
+            deadline: null,
+        });
+        await stateManager.saveGoal(child);
+        await stateManager.saveGoal(parent);
+        await aggregator.propagateStateDown("parent");
+        const updated = (await stateManager.loadGoal("child"));
+        expect(updated.deadline).toBe(childDeadline);
+    });
+    it("shortened parent deadline is propagated to child", async () => {
+        // child has 48h, parent now only has 12h → child should be capped
+        const childDeadline = hoursFromNow(48);
+        const parentDeadline = hoursFromNow(12);
+        const child = makeGoal({
+            id: "child",
+            parent_id: "parent",
+            deadline: childDeadline,
+        });
+        const parent = makeGoal({
+            id: "parent",
+            children_ids: ["child"],
+            deadline: parentDeadline,
+        });
+        await stateManager.saveGoal(child);
+        await stateManager.saveGoal(parent);
+        await aggregator.propagateStateDown("parent");
+        const updated = (await stateManager.loadGoal("child"));
+        const newMs = Date.parse(updated.deadline);
+        const parentMs = Date.parse(parentDeadline);
+        expect(newMs).toBeLessThanOrEqual(parentMs + 1000); // allow 1s slack
+    });
+    it("propagates deadline to multiple children", async () => {
+        const parentDeadline = hoursFromNow(6);
+        const c1 = makeGoal({ id: "c1", parent_id: "parent", deadline: hoursFromNow(48) });
+        const c2 = makeGoal({ id: "c2", parent_id: "parent", deadline: hoursFromNow(48) });
+        const parent = makeGoal({
+            id: "parent",
+            children_ids: ["c1", "c2"],
+            deadline: parentDeadline,
+        });
+        await stateManager.saveGoal(c1);
+        await stateManager.saveGoal(c2);
+        await stateManager.saveGoal(parent);
+        await aggregator.propagateStateDown("parent");
+        const parentMs = Date.parse(parentDeadline);
+        expect(Date.parse((await stateManager.loadGoal("c1")).deadline)).toBeLessThanOrEqual(parentMs + 1000);
+        expect(Date.parse((await stateManager.loadGoal("c2")).deadline)).toBeLessThanOrEqual(parentMs + 1000);
+    });
+});
+// ═══════════════════════════════════════════════════════════════════════════
+// 8. Completion cascade
+// ═══════════════════════════════════════════════════════════════════════════
+describe("checkCompletionCascade", async () => {
+    it("returns parent ID when all siblings are complete", async () => {
+        const c1 = makeGoal({ id: "c1", parent_id: "parent", status: "completed" });
+        const c2 = makeGoal({ id: "c2", parent_id: "parent", status: "completed" });
+        const parent = makeGoal({ id: "parent", children_ids: ["c1", "c2"] });
+        await stateManager.saveGoal(c1);
+        await stateManager.saveGoal(c2);
+        await stateManager.saveGoal(parent);
+        const result = await aggregator.checkCompletionCascade("c1");
+        expect(result).toContain("parent");
+    });
+    it("returns empty when one sibling is still active", async () => {
+        const c1 = makeGoal({ id: "c1", parent_id: "parent", status: "completed" });
+        const c2 = makeGoal({ id: "c2", parent_id: "parent", status: "active" });
+        const parent = makeGoal({ id: "parent", children_ids: ["c1", "c2"] });
+        await stateManager.saveGoal(c1);
+        await stateManager.saveGoal(c2);
+        await stateManager.saveGoal(parent);
+        const result = await aggregator.checkCompletionCascade("c1");
+        expect(result).toEqual([]);
+    });
+    it("cascades through multiple levels", async () => {
+        // leaf → mid → root
+        const leaf = makeGoal({ id: "leaf", parent_id: "mid", status: "completed" });
+        const mid = makeGoal({
+            id: "mid",
+            parent_id: "root",
+            children_ids: ["leaf"],
+            status: "active",
+        });
+        const root = makeGoal({ id: "root", children_ids: ["mid"] });
+        await stateManager.saveGoal(leaf);
+        await stateManager.saveGoal(mid);
+        await stateManager.saveGoal(root);
+        // After leaf completes, mid becomes eligible, then root
+        const result = await aggregator.checkCompletionCascade("leaf");
+        expect(result).toContain("mid");
+        expect(result).toContain("root");
+    });
+    it("stops cascade when a sibling at higher level is active", async () => {
+        // root has two children: mid (all children done) and blocker (active)
+        const leaf = makeGoal({ id: "leaf", parent_id: "mid", status: "completed" });
+        const mid = makeGoal({
+            id: "mid",
+            parent_id: "root",
+            children_ids: ["leaf"],
+            status: "active",
+        });
+        const blocker = makeGoal({ id: "blocker", parent_id: "root", status: "active" });
+        const root = makeGoal({ id: "root", children_ids: ["mid", "blocker"] });
+        await stateManager.saveGoal(leaf);
+        await stateManager.saveGoal(mid);
+        await stateManager.saveGoal(blocker);
+        await stateManager.saveGoal(root);
+        const result = await aggregator.checkCompletionCascade("leaf");
+        expect(result).toContain("mid");
+        expect(result).not.toContain("root");
+    });
+    it("cancelled child (merged) counts as done for cascade", async () => {
+        const c1 = makeGoal({ id: "c1", parent_id: "parent", status: "completed" });
+        const c2 = makeGoal({ id: "c2", parent_id: "parent", status: "cancelled" }); // merged/pruned
+        const parent = makeGoal({ id: "parent", children_ids: ["c1", "c2"] });
+        await stateManager.saveGoal(c1);
+        await stateManager.saveGoal(c2);
+        await stateManager.saveGoal(parent);
+        const result = await aggregator.checkCompletionCascade("c1");
+        expect(result).toContain("parent");
+    });
+    it("root goal becomes eligible when its only child completes", async () => {
+        const child = makeGoal({ id: "child", parent_id: "root-goal", status: "completed" });
+        const root = makeGoal({ id: "root-goal", parent_id: null, children_ids: ["child"] });
+        await stateManager.saveGoal(child);
+        await stateManager.saveGoal(root);
+        const result = await aggregator.checkCompletionCascade("child");
+        // root-goal becomes completable because its only child is done
+        expect(result).toContain("root-goal");
+    });
+    it("returns empty for a goal with no parent", async () => {
+        const standalone = makeGoal({ id: "standalone", parent_id: null });
+        await stateManager.saveGoal(standalone);
+        const result = await aggregator.checkCompletionCascade("standalone");
+        expect(result).toEqual([]);
+    });
+    it("result is ordered bottom-up (closest ancestor first)", async () => {
+        const l1 = makeGoal({ id: "l1", parent_id: "l2", status: "completed" });
+        const l2 = makeGoal({ id: "l2", parent_id: "l3", children_ids: ["l1"], status: "active" });
+        const l3 = makeGoal({ id: "l3", parent_id: null, children_ids: ["l2"] });
+        await stateManager.saveGoal(l1);
+        await stateManager.saveGoal(l2);
+        await stateManager.saveGoal(l3);
+        const result = await aggregator.checkCompletionCascade("l1");
+        expect(result[0]).toBe("l2");
+        expect(result[1]).toBe("l3");
+    });
+});
+// ═══════════════════════════════════════════════════════════════════════════
+// 9. 3+ layer nesting
+// ═══════════════════════════════════════════════════════════════════════════
+describe("3+ layer nesting", async () => {
+    it("deep tree aggregation uses correct child gaps at each level", async () => {
+        // root → mid → leaf
+        const leaf = makeGoal({
+            id: "leaf",
+            parent_id: "mid",
+            dimensions: [makeDimension({ current_value: 0 })], // gap 1.0
+        });
+        const mid = makeGoal({
+            id: "mid",
+            parent_id: "root",
+            children_ids: ["leaf"],
+        });
+        const root = makeGoal({
+            id: "root",
+            children_ids: ["mid"],
+        });
+        await stateManager.saveGoal(leaf);
+        await stateManager.saveGoal(mid);
+        await stateManager.saveGoal(root);
+        // Aggregate mid (its child is leaf with gap 1.0)
+        const midResult = await aggregator.aggregateChildStates("mid");
+        expect(midResult.aggregated_gap).toBeCloseTo(1.0, 5);
+        expect(midResult.child_gaps["leaf"]).toBeCloseTo(1.0, 5);
+    });
+    it("3-level cascade completes all the way to the root", async () => {
+        const l1 = makeGoal({ id: "l1", parent_id: "l2", status: "completed" });
+        const l2 = makeGoal({ id: "l2", parent_id: "l3", children_ids: ["l1"] });
+        const l3 = makeGoal({ id: "l3", parent_id: "l4", children_ids: ["l2"] });
+        const l4 = makeGoal({ id: "l4", parent_id: null, children_ids: ["l3"] });
+        await stateManager.saveGoal(l1);
+        await stateManager.saveGoal(l2);
+        await stateManager.saveGoal(l3);
+        await stateManager.saveGoal(l4);
+        const result = await aggregator.checkCompletionCascade("l1");
+        expect(result).toContain("l2");
+        expect(result).toContain("l3");
+        // l4 is root — it also becomes completable since all its children are done
+        expect(result).toContain("l4");
+    });
+    it("mid-level partial completion blocks grandparent cascade", async () => {
+        const l1a = makeGoal({ id: "l1a", parent_id: "l2", status: "completed" });
+        const l1b = makeGoal({ id: "l1b", parent_id: "l2", status: "active" }); // blocker
+        const l2 = makeGoal({ id: "l2", parent_id: "l3", children_ids: ["l1a", "l1b"] });
+        const l3 = makeGoal({ id: "l3", parent_id: null, children_ids: ["l2"] });
+        await stateManager.saveGoal(l1a);
+        await stateManager.saveGoal(l1b);
+        await stateManager.saveGoal(l2);
+        await stateManager.saveGoal(l3);
+        const result = await aggregator.checkCompletionCascade("l1a");
+        expect(result).not.toContain("l2");
+        expect(result).not.toContain("l3");
+    });
+    it("aggregation of a mid node includes only its direct children", async () => {
+        // root → mid → [leaf-a, leaf-b]
+        const leafA = makeGoal({
+            id: "leaf-a",
+            parent_id: "mid",
+            dimensions: [makeDimension({ current_value: 100 })], // gap 0
+        });
+        const leafB = makeGoal({
+            id: "leaf-b",
+            parent_id: "mid",
+            dimensions: [makeDimension({ current_value: 50 })], // gap 0.5
+        });
+        const mid = makeGoal({
+            id: "mid",
+            parent_id: "root",
+            children_ids: ["leaf-a", "leaf-b"],
+        });
+        const root = makeGoal({ id: "root", children_ids: ["mid"] });
+        await stateManager.saveGoal(leafA);
+        await stateManager.saveGoal(leafB);
+        await stateManager.saveGoal(mid);
+        await stateManager.saveGoal(root);
+        const midResult = await aggregator.aggregateChildStates("mid");
+        expect(midResult.child_gaps).toHaveProperty("leaf-a");
+        expect(midResult.child_gaps).toHaveProperty("leaf-b");
+        expect(midResult.child_gaps).not.toHaveProperty("root");
+        // default "min": picks smaller gap (leaf-a = 0)
+        expect(midResult.aggregated_gap).toBeCloseTo(0, 5);
+    });
+});
+// ═══════════════════════════════════════════════════════════════════════════
+// 10. Edge cases
+// ═══════════════════════════════════════════════════════════════════════════
+describe("edge cases", async () => {
+    it("parent with no children returns gap 0 and confidence 1.0", async () => {
+        const parent = makeGoal({ id: "no-kids", children_ids: [] });
+        await stateManager.saveGoal(parent);
+        const result = await aggregator.aggregateChildStates("no-kids");
+        expect(result.aggregated_gap).toBe(0);
+        expect(result.aggregated_confidence).toBe(1.0);
+    });
+    it("single child result mirrors that child's gap", async () => {
+        await buildTree(1, [{ dimensions: [makeDimension({ current_value: 75 })] }]);
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_gap).toBeCloseTo(0.25, 2);
+    });
+    it("missing child contributes gap 1.0 and confidence 0", async () => {
+        const parent = makeGoal({
+            id: "parent-ghost",
+            children_ids: ["ghost"],
+        });
+        await stateManager.saveGoal(parent);
+        const result = await aggregator.aggregateChildStates("parent-ghost");
+        expect(result.child_gaps["ghost"]).toBe(1.0);
+        expect(result.aggregated_confidence).toBe(0);
+    });
+    it("throws when parent not found in aggregateChildStates", async () => {
+        await expect(aggregator.aggregateChildStates("no-such-parent")).rejects.toThrow(/not found/);
+    });
+    it("throws when parent not found in propagateStateDown", async () => {
+        await expect(aggregator.propagateStateDown("no-such-parent")).rejects.toThrow(/not found/);
+    });
+    it("goal with empty dimensions has gap 0", async () => {
+        await buildTree(1, [{ dimensions: [] }]);
+        const result = await aggregator.aggregateChildStates("parent");
+        expect(result.aggregated_gap).toBe(0);
+    });
+});
+//# sourceMappingURL=state-aggregator.test.js.map