@stackmemoryai/stackmemory 0.3.1 → 0.3.3

package/dist/core/context/__tests__/frame-manager.test.js

@@ -1,879 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import Database from "better-sqlite3";
-import { FrameManager } from "../frame-manager";
-import { DatabaseError, FrameError, ErrorCode } from "../../errors/index";
-import { join } from "path";
-import { mkdtempSync, rmSync } from "fs";
-import { tmpdir } from "os";
-describe("FrameManager", () => {
-  let db;
-  let frameManager;
-  let tempDir;
-  const projectId = "test-project";
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), "stackmemory-test-"));
-    const dbPath = join(tempDir, "test.db");
-    db = new Database(dbPath);
-    frameManager = new FrameManager(db, projectId);
-  });
-  afterEach(() => {
-    if (db) {
-      db.close();
-    }
-    if (tempDir) {
-      rmSync(tempDir, { recursive: true, force: true });
-    }
-  });
-  describe("Initialization", () => {
-    it("should initialize database schema correctly", () => {
-      const tables = db.prepare(`
-        SELECT name FROM sqlite_master 
-        WHERE type='table' AND name IN ('frames', 'events', 'anchors')
-      `).all();
-      expect(tables).toHaveLength(3);
-      expect(tables.map((t) => t.name)).toContain("frames");
-      expect(tables.map((t) => t.name)).toContain("events");
-      expect(tables.map((t) => t.name)).toContain("anchors");
-    });
-    it("should load empty active stack on initialization", () => {
-      const stackDepth = frameManager.getStackDepth();
-      expect(stackDepth).toBe(0);
-    });
-  });
-  describe("Frame Creation", () => {
-    it("should create a new frame successfully", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Test Task",
-        inputs: { input: "test" }
-      });
-      expect(frameId).toBeDefined();
-      expect(typeof frameId).toBe("string");
-      const frame = frameManager.getFrame(frameId);
-      expect(frame).toBeDefined();
-      expect(frame.frame_id).toBe(frameId);
-      expect(frame.name).toBe("Test Task");
-      expect(frame.type).toBe("task");
-      expect(frame.state).toBe("active");
-      expect(frame.inputs).toEqual({ input: "test" });
-      expect(frame.depth).toBe(0);
-    });
-    it("should create nested frames with correct depth", () => {
-      const parentFrameId = frameManager.createFrame({
-        type: "task",
-        name: "Parent"
-      });
-      const childFrameId = frameManager.createFrame({
-        type: "subtask",
-        name: "Child"
-      });
-      const parentFrame = frameManager.getFrame(parentFrameId);
-      const childFrame = frameManager.getFrame(childFrameId);
-      expect(parentFrame.depth).toBe(0);
-      expect(childFrame.depth).toBe(1);
-      expect(childFrame.parent_frame_id).toBe(parentFrameId);
-    });
-    it("should update active stack when creating frames", () => {
-      const frame1Id = frameManager.createFrame({
-        type: "task",
-        name: "Frame 1"
-      });
-      const frame2Id = frameManager.createFrame({
-        type: "subtask",
-        name: "Frame 2"
-      });
-      const stackDepth = frameManager.getStackDepth();
-      expect(stackDepth).toBe(2);
-      expect(frameManager.getCurrentFrameId()).toBe(frame2Id);
-    });
-    it("should handle frame creation errors", () => {
-      db.close();
-      expect(() => {
-        frameManager.createFrame({
-          type: "task",
-          name: "Error Frame"
-        });
-      }).toThrow(DatabaseError);
-    });
-    it("should handle different frame types", () => {
-      const frameTypes = ["task", "subtask", "tool_scope", "review", "write", "debug"];
-      frameTypes.forEach((type) => {
-        const frameId = frameManager.createFrame({
-          type,
-          name: `${type} frame`
-        });
-        const frame = frameManager.getFrame(frameId);
-        expect(frame.type).toBe(type);
-      });
-    });
-    it("should create frames with specific parent", () => {
-      const rootFrameId = frameManager.createFrame({
-        type: "task",
-        name: "Root Frame"
-      });
-      const childFrameId = frameManager.createFrame({
-        type: "subtask",
-        name: "Child Frame",
-        parentFrameId: rootFrameId
-      });
-      const childFrame = frameManager.getFrame(childFrameId);
-      expect(childFrame.parent_frame_id).toBe(rootFrameId);
-      expect(childFrame.depth).toBe(1);
-    });
-  });
-  describe("Frame Closing", () => {
-    it("should close a frame successfully", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Test Frame"
-      });
-      frameManager.closeFrame(frameId, {
-        result: "completed",
-        data: "output"
-      });
-      const closedFrame = frameManager.getFrame(frameId);
-      expect(closedFrame.state).toBe("closed");
-      expect(closedFrame.outputs).toMatchObject({ data: "output" });
-      expect(closedFrame.closed_at).toBeDefined();
-    });
-    it("should generate digest when closing frame", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Digest Test"
-      });
-      frameManager.addEvent("user_message", {
-        content: "Test message"
-      }, frameId);
-      frameManager.closeFrame(frameId, {
-        result: "success"
-      });
-      const closedFrame = frameManager.getFrame(frameId);
-      expect(closedFrame.digest_text).toBeDefined();
-      expect(closedFrame.digest_json).toBeDefined();
-      expect(closedFrame.digest_text).toContain("Digest Test");
-    });
-    it("should remove from active stack when closing", () => {
-      const frame1Id = frameManager.createFrame({
-        type: "task",
-        name: "Frame 1"
-      });
-      const frame2Id = frameManager.createFrame({
-        type: "subtask",
-        name: "Frame 2"
-      });
-      frameManager.closeFrame(frame2Id);
-      const stackDepth = frameManager.getStackDepth();
-      expect(stackDepth).toBe(1);
-      expect(frameManager.getCurrentFrameId()).toBe(frame1Id);
-    });
-    it("should close current frame when no frameId specified", () => {
-      const frame1Id = frameManager.createFrame({
-        type: "task",
-        name: "Frame 1"
-      });
-      const frame2Id = frameManager.createFrame({
-        type: "subtask",
-        name: "Frame 2"
-      });
-      expect(frameManager.getCurrentFrameId()).toBe(frame2Id);
-      frameManager.closeFrame();
-      const closedFrame = frameManager.getFrame(frame2Id);
-      expect(closedFrame.state).toBe("closed");
-      expect(frameManager.getCurrentFrameId()).toBe(frame1Id);
-    });
-    it("should throw error when closing non-existent frame", () => {
-      expect(() => {
-        frameManager.closeFrame("non-existent-id");
-      }).toThrow(FrameError);
-    });
-    it("should warn when closing already closed frame", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Test"
-      });
-      frameManager.closeFrame(frameId);
-      expect(() => {
-        frameManager.closeFrame(frameId);
-      }).not.toThrow();
-    });
-    it("should close child frames recursively", () => {
-      const rootId = frameManager.createFrame({
-        type: "task",
-        name: "Root"
-      });
-      const child1Id = frameManager.createFrame({
-        type: "subtask",
-        name: "Child 1"
-      });
-      const child2Id = frameManager.createFrame({
-        type: "tool_scope",
-        name: "Child 2"
-      });
-      frameManager.closeFrame(rootId);
-      expect(frameManager.getFrame(rootId).state).toBe("closed");
-      expect(frameManager.getFrame(child1Id).state).toBe("closed");
-      expect(frameManager.getFrame(child2Id).state).toBe("closed");
-      expect(frameManager.getStackDepth()).toBe(0);
-    });
-    it("should throw error when no active frame to close", () => {
-      expect(() => {
-        frameManager.closeFrame();
-      }).toThrow(FrameError);
-    });
-  });
-  describe("Event Management", () => {
-    it("should add events to a frame", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Event Test"
-      });
-      const eventId = frameManager.addEvent(
-        "user_message",
-        { content: "Hello" },
-        frameId
-      );
-      expect(eventId).toBeDefined();
-      expect(typeof eventId).toBe("string");
-      const events = frameManager.getFrameEvents(frameId);
-      expect(events).toHaveLength(1);
-      expect(events[0].event_id).toBe(eventId);
-      expect(events[0].frame_id).toBe(frameId);
-      expect(events[0].event_type).toBe("user_message");
-      expect(events[0].payload).toEqual({ content: "Hello" });
-    });
-    it("should add events to current frame when no frameId specified", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Current Frame Test"
-      });
-      const eventId = frameManager.addEvent("user_message", { content: "Hello" });
-      const events = frameManager.getFrameEvents(frameId);
-      expect(events).toHaveLength(1);
-      expect(events[0].event_id).toBe(eventId);
-    });
-    it("should retrieve frame events", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Event Retrieval"
-      });
-      frameManager.addEvent("user_message", { msg: "1" }, frameId);
-      frameManager.addEvent("tool_call", { tool: "test" }, frameId);
-      frameManager.addEvent("tool_result", { result: "ok" }, frameId);
-      const events = frameManager.getFrameEvents(frameId);
-      expect(events).toHaveLength(3);
-      expect(events[0].event_type).toBe("user_message");
-      expect(events[1].event_type).toBe("tool_call");
-      expect(events[2].event_type).toBe("tool_result");
-    });
-    it("should maintain event sequence numbers", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Sequence Test"
-      });
-      frameManager.addEvent("user_message", { index: 1 }, frameId);
-      frameManager.addEvent("user_message", { index: 2 }, frameId);
-      frameManager.addEvent("user_message", { index: 3 }, frameId);
-      const events = frameManager.getFrameEvents(frameId);
-      expect(events[0].seq).toBe(1);
-      expect(events[1].seq).toBe(2);
-      expect(events[2].seq).toBe(3);
-    });
-    it("should limit frame events when requested", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Limit Test"
-      });
-      for (let i = 0; i < 20; i++) {
-        frameManager.addEvent("user_message", { index: i }, frameId);
-      }
-      const limitedEvents = frameManager.getFrameEvents(frameId, 5);
-      expect(limitedEvents).toHaveLength(5);
-      expect(limitedEvents[0].payload.index).toBe(19);
-      expect(limitedEvents[4].payload.index).toBe(15);
-    });
-    it("should throw error when adding event with no active frame", () => {
-      expect(() => {
-        frameManager.addEvent("user_message", { content: "test" });
-      }).toThrow(FrameError);
-    });
-    it("should handle different event types", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Event Types Test"
-      });
-      const eventTypes = [
-        "user_message",
-        "assistant_message",
-        "tool_call",
-        "tool_result",
-        "decision",
-        "constraint",
-        "artifact",
-        "observation"
-      ];
-      eventTypes.forEach((type) => {
-        frameManager.addEvent(type, { type }, frameId);
-      });
-      const events = frameManager.getFrameEvents(frameId);
-      expect(events).toHaveLength(eventTypes.length);
-      eventTypes.forEach((type, index) => {
-        expect(events[index].event_type).toBe(type);
-      });
-    });
-  });
-  describe("Anchor Management", () => {
-    it("should add anchors to a frame", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Anchor Test"
-      });
-      const anchorId = frameManager.addAnchor(
-        "FACT",
-        "Important fact",
-        9
-        // priority 0-10
-      );
-      expect(anchorId).toBeDefined();
-      expect(typeof anchorId).toBe("string");
-    });
-    it("should add anchors to current frame when no frameId specified", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Current Frame Anchor Test"
-      });
-      const anchorId = frameManager.addAnchor("FACT", "Important fact", 9);
-      expect(anchorId).toBeDefined();
-    });
-    it("should handle different anchor types", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Anchor Types"
-      });
-      const anchorTypes = [
-        "FACT",
-        "DECISION",
-        "CONSTRAINT",
-        "INTERFACE_CONTRACT",
-        "TODO",
-        "RISK"
-      ];
-      anchorTypes.forEach((type) => {
-        const anchorId = frameManager.addAnchor(
-          type,
-          `${type} content`,
-          5,
-          { testMetadata: true },
-          frameId
-        );
-        expect(anchorId).toBeDefined();
-      });
-    });
-    it("should handle metadata in anchors", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Metadata Test"
-      });
-      const metadata = {
-        source: "test",
-        confidence: 0.95,
-        tags: ["important", "decision"]
-      };
-      const anchorId = frameManager.addAnchor(
-        "DECISION",
-        "Decision with metadata",
-        8,
-        metadata,
-        frameId
-      );
-      expect(anchorId).toBeDefined();
-    });
-    it("should use default priority when not specified", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Default Priority Test"
-      });
-      const anchorId = frameManager.addAnchor("TODO", "Task without priority");
-      expect(anchorId).toBeDefined();
-    });
-    it("should throw error when adding anchor with no active frame", () => {
-      expect(() => {
-        frameManager.addAnchor("FACT", "No active frame");
-      }).toThrow(FrameError);
-    });
-  });
-  describe("Context Assembly", () => {
-    it("should get hot stack context with active frames", () => {
-      const frame1Id = frameManager.createFrame({
-        type: "task",
-        name: "Frame 1"
-      });
-      const frame2Id = frameManager.createFrame({
-        type: "subtask",
-        name: "Frame 2"
-      });
-      const frame3Id = frameManager.createFrame({
-        type: "tool_scope",
-        name: "Frame 3"
-      });
-      const hotStack = frameManager.getHotStackContext(5);
-      expect(hotStack).toHaveLength(3);
-      expect(hotStack[0].frameId).toBe(frame1Id);
-      expect(hotStack[1].frameId).toBe(frame2Id);
-      expect(hotStack[2].frameId).toBe(frame3Id);
-    });
-    it("should assemble frame context correctly", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Context Test",
-        inputs: {
-          constraints: ["constraint1", "constraint2"],
-          definitions: { key: "value" }
-        }
-      });
-      frameManager.addEvent("user_message", {
-        content: "Test message"
-      }, frameId);
-      frameManager.addAnchor("FACT", "Important fact", 9, {}, frameId);
-      const hotStack = frameManager.getHotStackContext(10);
-      const context = hotStack.find((ctx) => ctx.frameId === frameId);
-      expect(context).toBeDefined();
-      expect(context.frameId).toBe(frameId);
-      expect(context.header.goal).toBe("Context Test");
-      expect(context.header.constraints).toEqual(["constraint1", "constraint2"]);
-      expect(context.header.definitions).toEqual({ key: "value" });
-      expect(context.anchors).toHaveLength(1);
-      expect(context.recentEvents).toHaveLength(1);
-    });
-    it("should limit events in context assembly", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Event Limit Test"
-      });
-      for (let i = 0; i < 20; i++) {
-        frameManager.addEvent("user_message", { index: i }, frameId);
-      }
-      const hotStack = frameManager.getHotStackContext(5);
-      const context = hotStack.find((ctx) => ctx.frameId === frameId);
-      expect(context.recentEvents).toHaveLength(5);
-    });
-    it("should return empty hot stack when no active frames", () => {
-      const hotStack = frameManager.getHotStackContext();
-      expect(hotStack).toHaveLength(0);
-    });
-    it("should get active frame path", () => {
-      const frame1Id = frameManager.createFrame({
-        type: "task",
-        name: "Root Frame"
-      });
-      const frame2Id = frameManager.createFrame({
-        type: "subtask",
-        name: "Child Frame"
-      });
-      const activePath = frameManager.getActiveFramePath();
-      expect(activePath).toHaveLength(2);
-      expect(activePath[0].frame_id).toBe(frame1Id);
-      expect(activePath[0].name).toBe("Root Frame");
-      expect(activePath[1].frame_id).toBe(frame2Id);
-      expect(activePath[1].name).toBe("Child Frame");
-    });
-    it("should extract active artifacts from events", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Artifact Test"
-      });
-      frameManager.addEvent("artifact", {
-        ref: "/path/to/file1.ts",
-        kind: "file"
-      }, frameId);
-      frameManager.addEvent("artifact", {
-        ref: "/path/to/file2.ts",
-        kind: "file"
-      }, frameId);
-      const hotStack = frameManager.getHotStackContext();
-      const context = hotStack.find((ctx) => ctx.frameId === frameId);
-      expect(context.activeArtifacts).toHaveLength(2);
-      expect(context.activeArtifacts).toContain("/path/to/file1.ts");
-      expect(context.activeArtifacts).toContain("/path/to/file2.ts");
-    });
-  });
-  describe("Frame Retrieval", () => {
-    it("should get frame by ID", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Get Test"
-      });
-      const retrieved = frameManager.getFrame(frameId);
-      expect(retrieved).toBeDefined();
-      expect(retrieved.frame_id).toBe(frameId);
-      expect(retrieved.name).toBe("Get Test");
-    });
-    it("should return undefined for non-existent frame", () => {
-      const frame = frameManager.getFrame("non-existent");
-      expect(frame).toBeUndefined();
-    });
-    it("should get current frame ID (top of stack)", () => {
-      const frame1Id = frameManager.createFrame({
-        type: "task",
-        name: "Frame 1"
-      });
-      const frame2Id = frameManager.createFrame({
-        type: "subtask",
-        name: "Frame 2"
-      });
-      const currentFrameId = frameManager.getCurrentFrameId();
-      expect(currentFrameId).toBe(frame2Id);
-    });
-    it("should return undefined when stack is empty", () => {
-      const currentFrameId = frameManager.getCurrentFrameId();
-      expect(currentFrameId).toBeUndefined();
-    });
-    it("should get stack depth", () => {
-      expect(frameManager.getStackDepth()).toBe(0);
-      frameManager.createFrame({
-        type: "task",
-        name: "Frame 1"
-      });
-      expect(frameManager.getStackDepth()).toBe(1);
-      frameManager.createFrame({
-        type: "subtask",
-        name: "Frame 2"
-      });
-      expect(frameManager.getStackDepth()).toBe(2);
-    });
-    it("should handle frame with all properties", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Complete Test",
-        inputs: {
-          test: true,
-          data: { nested: "value" },
-          list: [1, 2, 3]
-        }
-      });
-      const frame = frameManager.getFrame(frameId);
-      expect(frame.frame_id).toBe(frameId);
-      expect(frame.run_id).toBeDefined();
-      expect(frame.project_id).toBe(projectId);
-      expect(frame.parent_frame_id).toBeNull();
-      expect(frame.depth).toBe(0);
-      expect(frame.type).toBe("task");
-      expect(frame.name).toBe("Complete Test");
-      expect(frame.state).toBe("active");
-      expect(frame.inputs).toEqual({
-        test: true,
-        data: { nested: "value" },
-        list: [1, 2, 3]
-      });
-      expect(frame.outputs).toEqual({});
-      expect(frame.digest_json).toEqual({});
-      expect(frame.created_at).toBeDefined();
-      expect(frame.closed_at).toBeNull();
-    });
-  });
-  describe("Digest Generation", () => {
-    it("should generate meaningful digest", async () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Digest Frame"
-      });
-      frameManager.addEvent("user_message", {
-        content: "What is the weather?"
-      }, frameId);
-      frameManager.addEvent("tool_call", {
-        tool: "weather_api",
-        params: { location: "NYC" }
-      }, frameId);
-      frameManager.addEvent("tool_result", {
-        result: "Sunny, 72\xB0F"
-      }, frameId);
-      frameManager.addEvent("artifact", {
-        kind: "file",
-        ref: "/path/to/weather.json"
-      }, frameId);
-      frameManager.addAnchor("FACT", "Weather is sunny", 9, {}, frameId);
-      frameManager.addAnchor("DECISION", "No umbrella needed", 8, {}, frameId);
-      frameManager.addAnchor("RISK", "Rain possible later", 3, {}, frameId);
-      await new Promise((resolve) => setTimeout(resolve, 1100));
-      frameManager.closeFrame(frameId, {
-        result: "Weather information provided",
-        data: "temperature: 72\xB0F"
-      });
-      const closedFrame = frameManager.getFrame(frameId);
-      expect(closedFrame.digest_text).toContain("Completed: Digest Frame");
-      expect(closedFrame.digest_text).toContain("Decisions made");
-      expect(closedFrame.digest_text).toContain("No umbrella needed");
-      expect(closedFrame.digest_text).toContain("Rain possible later");
-      expect(closedFrame.digest_text).toContain("4 events");
-      expect(closedFrame.digest_text).toContain("1 tool calls");
-      const digest = closedFrame.digest_json;
-      expect(digest.result).toBe("Digest Frame");
-      expect(digest.decisions).toHaveLength(1);
-      expect(digest.decisions[0].text).toBe("No umbrella needed");
-      expect(digest.risks).toHaveLength(1);
-      expect(digest.risks[0].text).toBe("Rain possible later");
-      expect(digest.artifacts).toHaveLength(1);
-      expect(digest.artifacts[0].ref).toBe("/path/to/weather.json");
-      expect(digest.tool_calls_count).toBe(1);
-      expect(digest.duration_seconds).toBeGreaterThanOrEqual(0);
-    });
-  });
-  describe("Error Handling", () => {
-    it("should handle database errors gracefully", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Error Test"
-      });
-      db.close();
-      expect(() => {
-        frameManager.addEvent("user_message", {}, frameId);
-      }).toThrow(DatabaseError);
-    });
-    it("should validate frame types", () => {
-      const validTypes = [
-        "task",
-        "subtask",
-        "tool_scope",
-        "review",
-        "write",
-        "debug"
-      ];
-      validTypes.forEach((type) => {
-        const frameId = frameManager.createFrame({
-          type,
-          name: `${type} frame`
-        });
-        const frame = frameManager.getFrame(frameId);
-        expect(frame.type).toBe(type);
-      });
-    });
-    it("should handle concurrent frame operations", () => {
-      const frameIds = [];
-      for (let i = 0; i < 10; i++) {
-        frameIds.push(frameManager.createFrame({
-          type: "task",
-          name: `Frame ${i}`
-        }));
-      }
-      expect(frameIds).toHaveLength(10);
-      expect(frameManager.getStackDepth()).toBe(10);
-      for (let i = 9; i >= 0; i--) {
-        frameManager.closeFrame(frameIds[i]);
-      }
-      expect(frameManager.getStackDepth()).toBe(0);
-    });
-    it("should handle database query errors gracefully", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Query Error Test"
-      });
-      db.close();
-      expect(() => frameManager.getFrame(frameId)).toThrow(DatabaseError);
-      expect(() => frameManager.getFrameEvents(frameId)).toThrow(DatabaseError);
-    });
-    it("should provide meaningful error messages", () => {
-      try {
-        frameManager.closeFrame("invalid-frame-id");
-        expect.fail("Should have thrown an error");
-      } catch (error) {
-        expect(error).toBeInstanceOf(FrameError);
-        expect(error.message).toContain("Frame not found");
-        expect(error.code).toBe(ErrorCode.FRAME_NOT_FOUND);
-      }
-    });
-    it("should include context in error metadata", () => {
-      try {
-        frameManager.addAnchor("FACT", "Test fact");
-        expect.fail("Should have thrown an error");
-      } catch (error) {
-        expect(error).toBeInstanceOf(FrameError);
-        expect(error.context).toMatchObject({
-          operation: "addAnchor",
-          anchorType: "FACT"
-        });
-      }
-    });
-  });
-  describe("Complex Scenarios", () => {
-    it("should handle deep nesting", () => {
-      const frameIds = [];
-      const maxDepth = 10;
-      for (let i = 0; i < maxDepth; i++) {
-        const frameId = frameManager.createFrame({
-          type: i === 0 ? "task" : "subtask",
-          name: `Level ${i}`
-        });
-        frameIds.push(frameId);
-        const frame = frameManager.getFrame(frameId);
-        expect(frame.depth).toBe(i);
-      }
-      expect(frameManager.getStackDepth()).toBe(maxDepth);
-      for (let i = maxDepth - 1; i >= 0; i--) {
-        frameManager.closeFrame(frameIds[i]);
-      }
-      expect(frameManager.getStackDepth()).toBe(0);
-    });
-    it("should handle frame with many events and anchors", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Heavy Frame"
-      });
-      for (let i = 0; i < 100; i++) {
-        frameManager.addEvent("user_message", { index: i }, frameId);
-      }
-      const anchorTypes = ["FACT", "DECISION", "CONSTRAINT", "TODO", "RISK"];
-      for (let i = 0; i < 50; i++) {
-        frameManager.addAnchor(
-          anchorTypes[i % anchorTypes.length],
-          `Content ${i}`,
-          Math.floor(Math.random() * 10),
-          { index: i },
-          frameId
-        );
-      }
-      const events = frameManager.getFrameEvents(frameId);
-      expect(events).toHaveLength(100);
-      frameManager.closeFrame(frameId, {
-        result: "Heavy frame completed",
-        processedEvents: 100,
-        processedAnchors: 50
-      });
-      const closedFrame = frameManager.getFrame(frameId);
-      expect(closedFrame.digest_text).toBeDefined();
-      expect(closedFrame.digest_json).toBeDefined();
-      expect(closedFrame.digest_json.tool_calls_count).toBe(0);
-      expect(closedFrame.state).toBe("closed");
-    });
-    it("should handle frame inheritance with specific parent", () => {
-      const rootId = frameManager.createFrame({
-        type: "task",
-        name: "Root Task"
-      });
-      const childId = frameManager.createFrame({
-        type: "subtask",
-        name: "Child Task",
-        parentFrameId: rootId
-      });
-      const grandchildId = frameManager.createFrame({
-        type: "tool_scope",
-        name: "Grandchild Task",
-        parentFrameId: childId
-      });
-      const rootFrame = frameManager.getFrame(rootId);
-      const childFrame = frameManager.getFrame(childId);
-      const grandchildFrame = frameManager.getFrame(grandchildId);
-      expect(rootFrame.depth).toBe(0);
-      expect(childFrame.depth).toBe(1);
-      expect(grandchildFrame.depth).toBe(2);
-      expect(rootFrame.parent_frame_id).toBeNull();
-      expect(childFrame.parent_frame_id).toBe(rootId);
-      expect(grandchildFrame.parent_frame_id).toBe(childId);
-    });
-    it("should handle session recovery with existing frames", () => {
-      const frame1Id = frameManager.createFrame({
-        type: "task",
-        name: "Existing Frame 1"
-      });
-      const frame2Id = frameManager.createFrame({
-        type: "subtask",
-        name: "Existing Frame 2"
-      });
-      const originalRunId = frameManager.currentRunId;
-      const newFrameManager = new FrameManager(db, projectId, originalRunId);
-      expect(newFrameManager.getStackDepth()).toBe(2);
-      expect(newFrameManager.getCurrentFrameId()).toBe(frame2Id);
-      newFrameManager.addEvent("observation", { message: "Session recovered" });
-      newFrameManager.closeFrame();
-      expect(newFrameManager.getStackDepth()).toBe(1);
-      expect(newFrameManager.getCurrentFrameId()).toBe(frame1Id);
-    });
-    it("should handle mixed event and anchor operations", () => {
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "Mixed Operations"
-      });
-      frameManager.addEvent("user_message", { msg: "Start task" }, frameId);
-      frameManager.addAnchor("FACT", "Task started", 8, {}, frameId);
-      frameManager.addEvent("tool_call", { tool: "analyzer" }, frameId);
-      frameManager.addAnchor("DECISION", "Use analyzer tool", 9, {}, frameId);
-      frameManager.addEvent("tool_result", { result: "Analysis complete" }, frameId);
-      frameManager.addAnchor("CONSTRAINT", "Must validate results", 7, {}, frameId);
-      frameManager.addEvent("assistant_message", { msg: "Task complete" }, frameId);
-      frameManager.addAnchor("TODO", "Document findings", 5, {}, frameId);
-      const events = frameManager.getFrameEvents(frameId);
-      expect(events).toHaveLength(4);
-      const hotStack = frameManager.getHotStackContext();
-      const context = hotStack.find((ctx) => ctx.frameId === frameId);
-      expect(context.anchors).toHaveLength(4);
-      expect(context.recentEvents).toHaveLength(4);
-      const eventMessages = context.recentEvents.map((e) => e.payload.msg).filter(Boolean);
-      expect(eventMessages).toContain("Start task");
-      expect(eventMessages).toContain("Task complete");
-    });
-    it("should handle closing frames out of order", () => {
-      const rootId = frameManager.createFrame({
-        type: "task",
-        name: "Root"
-      });
-      const child1Id = frameManager.createFrame({
-        type: "subtask",
-        name: "Child 1"
-      });
-      const child2Id = frameManager.createFrame({
-        type: "tool_scope",
-        name: "Child 2"
-      });
-      expect(frameManager.getStackDepth()).toBe(3);
-      frameManager.closeFrame(child1Id);
-      expect(frameManager.getFrame(child1Id).state).toBe("closed");
-      expect(frameManager.getFrame(child2Id).state).toBe("closed");
-      expect(frameManager.getStackDepth()).toBe(1);
-      expect(frameManager.getCurrentFrameId()).toBe(rootId);
-    });
-  });
-  describe("Database Schema and Persistence", () => {
-    it("should initialize all required tables", () => {
-      const tables = db.prepare(`
-        SELECT name FROM sqlite_master 
-        WHERE type='table' AND name IN ('frames', 'events', 'anchors')
-      `).all();
-      expect(tables).toHaveLength(3);
-      expect(tables.map((t) => t.name)).toContain("frames");
-      expect(tables.map((t) => t.name)).toContain("events");
-      expect(tables.map((t) => t.name)).toContain("anchors");
-    });
-    it("should create required indexes", () => {
-      const indexes = db.prepare(`
-        SELECT name FROM sqlite_master 
-        WHERE type='index' AND name LIKE 'idx_%'
-      `).all();
-      const expectedIndexes = [
-        "idx_frames_run",
-        "idx_frames_parent",
-        "idx_frames_state",
-        "idx_events_frame",
-        "idx_events_seq",
-        "idx_anchors_frame"
-      ];
-      expectedIndexes.forEach((expectedIndex) => {
-        expect(indexes.some((idx) => idx.name === expectedIndex)).toBe(true);
-      });
-    });
-    it("should handle JSON serialization correctly", () => {
-      const complexInputs = {
-        nested: { deep: { value: "test" } },
-        array: [1, 2, { key: "value" }],
-        boolean: true,
-        number: 42.5,
-        null: null
-      };
-      const frameId = frameManager.createFrame({
-        type: "task",
-        name: "JSON Test",
-        inputs: complexInputs
-      });
-      const frame = frameManager.getFrame(frameId);
-      expect(frame.inputs).toEqual(complexInputs);
-    });
-  });
-});
-//# sourceMappingURL=frame-manager.test.js.map