@aria-cli/tools 1.0.8 → 1.0.10

package/tests/executors/memory.test.ts

@@ -1,853 +0,0 @@
-/**
- * @aria/tools - Memory executor tests
- */
-
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import type { ToolContext } from "../../src/types.js";
-import {
-  executeRemember,
-  executeRecall,
-  executeForget,
-  executeDiscover,
-  executeReflect,
-} from "../../src/executors/memory.js";
-
-// Mock Memoria interface matching @aria/memoria
-interface MockMemory {
-  id: string;
-  content: string;
-  importance: number;
-  metadata?: Record<string, unknown>;
-}
-
-interface MockKnowledge {
-  id: string;
-  name: string;
-  description: string;
-  tags: string[];
-  source?: { type: string; [key: string]: unknown };
-}
-
-// Helper to create a mock Memoria instance
-const createMockMemoria = () => ({
-  remember: vi.fn(),
-  recall: vi.fn(),
-  recallTools: vi.fn(),
-  rememberSkill: vi.fn().mockResolvedValue("skill-id"),
-  recallSkills: vi.fn().mockResolvedValue([]),
-  getSkill: vi.fn().mockResolvedValue(null),
-  recordSkillExecution: vi
-    .fn()
-    .mockResolvedValue({ id: "exec-1", skillId: "s1", success: true, timestamp: new Date() }),
-  deleteMemory: vi.fn(),
-});
-
-// Helper to create a mock router
-const createMockRouter = () => ({
-  chat: vi.fn().mockResolvedValue({ content: "{}" }),
-});
-
-// Helper to create a context with mock Memoria
-const createContext = (
-  workingDir: string,
-  memoria?: ReturnType<typeof createMockMemoria>,
-  overrides?: Partial<ToolContext>,
-): ToolContext => ({
-  workingDir,
-  memoria,
-  env: {},
-  confirm: async () => true,
-  ...overrides,
-});
-
-describe("Memory Executors", () => {
-  let mockMemoria: ReturnType<typeof createMockMemoria>;
-  let ctx: ToolContext;
-
-  beforeEach(() => {
-    mockMemoria = createMockMemoria();
-    mockMemoria.recallTools.mockResolvedValue([]);
-    mockMemoria.recallSkills.mockResolvedValue([]);
-    ctx = createContext("/test/dir", mockMemoria);
-  });
-
-  describe("executeRemember", () => {
-    it("should store content in memoria with id returned", async () => {
-      const mockResult: MockMemory = {
-        id: "mem-123",
-        content: "Test content to remember",
-        importance: 0.8,
-      };
-      mockMemoria.remember.mockResolvedValue(mockResult);
-
-      const result = await executeRemember({ content: "Test content to remember" }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toEqual({ id: "mem-123" });
-      expect(mockMemoria.remember).toHaveBeenCalledWith("Test content to remember", {});
-    });
-
-    it("should pass importance when provided", async () => {
-      const mockResult: MockMemory = {
-        id: "mem-789",
-        content: "Important content",
-        importance: 0.95,
-      };
-      mockMemoria.remember.mockResolvedValue(mockResult);
-
-      const result = await executeRemember({ content: "Important content", importance: 0.95 }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(mockMemoria.remember).toHaveBeenCalledWith("Important content", {
-        importance: 0.95,
-      });
-    });
-
-    it("should return error when memoria is not available", async () => {
-      const ctxNoMemoria = createContext("/test/dir");
-
-      const result = await executeRemember({ content: "Test content" }, ctxNoMemoria);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Memoria");
-    });
-
-    it("should return error when content is empty", async () => {
-      const result = await executeRemember({ content: "" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("content");
-    });
-
-    it("should return error when importance is below 0.0", async () => {
-      const result = await executeRemember({ content: "Test content", importance: -0.1 }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("importance must be between 0.0 and 1.0");
-    });
-
-    it("should return error when importance is above 1.0", async () => {
-      const result = await executeRemember({ content: "Test content", importance: 1.5 }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("importance must be between 0.0 and 1.0");
-    });
-
-    it("should accept importance at boundary values (0.0 and 1.0)", async () => {
-      const mockResult: MockMemory = {
-        id: "mem-boundary",
-        content: "Boundary test",
-        importance: 0.0,
-      };
-      mockMemoria.remember.mockResolvedValue(mockResult);
-
-      // Test 0.0
-      const result0 = await executeRemember({ content: "Boundary test", importance: 0.0 }, ctx);
-      expect(result0.success).toBe(true);
-
-      // Test 1.0
-      mockResult.importance = 1.0;
-      const result1 = await executeRemember({ content: "Boundary test", importance: 1.0 }, ctx);
-      expect(result1.success).toBe(true);
-    });
-
-    it("should return error when importance is NaN", async () => {
-      const result = await executeRemember({ content: "Test content", importance: NaN }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("importance must be a finite number");
-    });
-
-    it("should return error when importance is Infinity", async () => {
-      const result = await executeRemember({ content: "Test content", importance: Infinity }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("importance must be a finite number");
-    });
-
-    it("should handle memoria errors gracefully", async () => {
-      mockMemoria.remember.mockRejectedValue(new Error("Database error"));
-
-      const result = await executeRemember({ content: "Test content" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Database error");
-    });
-  });
-
-  describe("executeRecall", () => {
-    it("should query memories by search query", async () => {
-      const mockMemories: MockMemory[] = [
-        { id: "mem-1", content: "First memory", importance: 0.8 },
-        { id: "mem-2", content: "Second memory", importance: 0.7 },
-      ];
-      mockMemoria.recall.mockResolvedValue({ memories: mockMemories });
-
-      const result = await executeRecall({ query: "search term" }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toMatchObject({
-        memories: mockMemories,
-        count: 2,
-      });
-      expect(mockMemoria.recall).toHaveBeenCalledWith(
-        "search term",
-        expect.objectContaining({ limit: 10 }),
-      );
-    });
-
-    it("should respect limit parameter", async () => {
-      const mockMemories: MockMemory[] = [{ id: "mem-1", content: "Memory", importance: 0.8 }];
-      mockMemoria.recall.mockResolvedValue({ memories: mockMemories });
-
-      const result = await executeRecall({ query: "search", limit: 5 }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(mockMemoria.recall).toHaveBeenCalledWith(
-        "search",
-        expect.objectContaining({ limit: 5 }),
-      );
-    });
-
-    it("should return empty array when no memories found", async () => {
-      mockMemoria.recall.mockResolvedValue({ memories: [] });
-
-      const result = await executeRecall({ query: "nonexistent" }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toMatchObject({
-        memories: [],
-        count: 0,
-      });
-    });
-
-    it("should return error when memoria is not available", async () => {
-      const ctxNoMemoria = createContext("/test/dir");
-
-      const result = await executeRecall({ query: "search" }, ctxNoMemoria);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Memoria");
-    });
-
-    it("should return error when query is empty", async () => {
-      const result = await executeRecall({ query: "" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("query");
-    });
-
-    it("should handle memoria errors gracefully", async () => {
-      mockMemoria.recall.mockRejectedValue(new Error("Search failed"));
-
-      const result = await executeRecall({ query: "test" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Search failed");
-    });
-  });
-
-  describe("executeForget", () => {
-    it("should delete memory by ID", async () => {
-      mockMemoria.deleteMemory.mockResolvedValue(true);
-
-      const result = await executeForget({ id: "mem-123" }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toEqual({ deleted: true, id: "mem-123" });
-      expect(mockMemoria.deleteMemory).toHaveBeenCalledWith("mem-123");
-    });
-
-    it("should return success false when memory not found", async () => {
-      mockMemoria.deleteMemory.mockResolvedValue(false);
-
-      const result = await executeForget({ id: "nonexistent" }, ctx);
-
-      expect(result.success).toBe(false);
-    });
-
-    it("should return error when memoria is not available", async () => {
-      const ctxNoMemoria = createContext("/test/dir");
-
-      const result = await executeForget({ id: "mem-123" }, ctxNoMemoria);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Memoria");
-    });
-
-    it("should return error when id is empty", async () => {
-      const result = await executeForget({ id: "" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("id");
-    });
-
-    it("should handle memoria errors gracefully", async () => {
-      mockMemoria.deleteMemory.mockRejectedValue(new Error("Delete failed"));
-
-      const result = await executeForget({ id: "mem-123" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Delete failed");
-    });
-  });
-
-  describe("executeDiscover", () => {
-    it("should query recallTools and return insights", async () => {
-      const mockKnowledge: MockKnowledge[] = [
-        {
-          id: "k-1",
-          name: "Tool usage pattern",
-          description: "Common pattern for file operations",
-          tags: ["files", "operations"],
-        },
-        {
-          id: "k-2",
-          name: "Related skill",
-          description: "A skill for automation",
-          tags: ["automation"],
-        },
-      ];
-      mockMemoria.recallTools.mockResolvedValue(mockKnowledge);
-
-      const result = await executeDiscover({ topic: "file operations" }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toMatchObject({
-        tools: mockKnowledge,
-        toolCount: 2,
-        skillCount: 0,
-      });
-      expect(mockMemoria.recallTools).toHaveBeenCalledWith({
-        query: "file operations",
-        limit: 10,
-      });
-      expect(mockMemoria.recallSkills).toHaveBeenCalledWith({
-        query: "file operations",
-        limit: 10,
-      });
-    });
-
-    it("should respect limit parameter", async () => {
-      const result = await executeDiscover({ topic: "topic", limit: 5 }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(mockMemoria.recallTools).toHaveBeenCalledWith({
-        query: "topic",
-        limit: 5,
-      });
-      expect(mockMemoria.recallSkills).toHaveBeenCalledWith({
-        query: "topic",
-        limit: 5,
-      });
-    });
-
-    it("should merge recallSkills results when kind is omitted", async () => {
-      mockMemoria.recallTools.mockResolvedValue([
-        {
-          id: "tool-1",
-          name: "read_file",
-          description: "Read file contents",
-          tags: [],
-        },
-      ]);
-      mockMemoria.recallSkills.mockResolvedValue([
-        {
-          id: "skill-1",
-          name: "Deploy app",
-          description: "Deploy workflow",
-          content: "Task: deploy app",
-          toolIds: ["bash", "grep"],
-          triggers: [{ type: "keyword", pattern: "deploy", confidence: 0.8 }],
-          source: { type: "auto-learned", sequenceId: "seq-1" },
-          importance: 0.7,
-          confidence: 0.8,
-          createdAt: new Date("2026-01-01T00:00:00Z"),
-          updatedAt: new Date("2026-01-01T00:00:00Z"),
-          accessedAt: new Date("2026-01-01T00:00:00Z"),
-          accessCount: 0,
-        },
-      ]);
-
-      const result = await executeDiscover({ topic: "deploy app", limit: 5 }, ctx);
-      expect(result.success).toBe(true);
-      const data = result.data as {
-        tools: Array<{ id: string }>;
-        skills: Array<{ id: string }>;
-        toolCount: number;
-        skillCount: number;
-      };
-      expect(data.toolCount + data.skillCount).toBe(2);
-      expect(data.skills.some((item) => item.id === "skill-1")).toBe(true);
-      expect(data.tools.some((item) => item.id === "tool-1")).toBe(true);
-    });
-
-    it("should filter by kind when provided", async () => {
-      mockMemoria.recallSkills.mockResolvedValue([]);
-
-      const result = await executeDiscover({ topic: "topic" }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(mockMemoria.recallSkills).toHaveBeenCalledWith({
-        query: "topic",
-        limit: 10,
-      });
-      expect(mockMemoria.recallTools).not.toHaveBeenCalledWith(
-        expect.objectContaining({ kind: "skill" }),
-      );
-    });
-
-    it("should return empty insights when no knowledge found", async () => {
-      const result = await executeDiscover({ topic: "unknown topic" }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toMatchObject({
-        tools: [],
-        skills: [],
-        toolCount: 0,
-        skillCount: 0,
-      });
-    });
-
-    it("should return error when memoria is not available", async () => {
-      const ctxNoMemoria = createContext("/test/dir");
-
-      const result = await executeDiscover({ topic: "test" }, ctxNoMemoria);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Memoria");
-    });
-
-    it("should return error when topic is empty", async () => {
-      const result = await executeDiscover({ topic: "" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("topic");
-    });
-
-    it("should degrade gracefully when one recall source errors", async () => {
-      mockMemoria.recallTools.mockRejectedValue(new Error("Knowledge query failed"));
-      mockMemoria.recallSkills.mockResolvedValue([]);
-
-      const result = await executeDiscover({ topic: "test" }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toMatchObject({
-        tools: [],
-        skills: [],
-        toolCount: 0,
-        skillCount: 0,
-      });
-    });
-
-    it("should fail when both recall sources error", async () => {
-      mockMemoria.recallTools.mockRejectedValue(new Error("Tools query failed"));
-      mockMemoria.recallSkills.mockRejectedValue(new Error("Skills query failed"));
-
-      const result = await executeDiscover({ topic: "test" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Tools query failed");
-      expect(result.message).toContain("Skills query failed");
-    });
-
-    it("should generate insights summary from knowledge", async () => {
-      const mockKnowledge: MockKnowledge[] = [
-        {
-          id: "k-1",
-          name: "Git workflow",
-          description: "How to work with git branching",
-          tags: ["git", "workflow"],
-        },
-      ];
-      mockMemoria.recallTools.mockResolvedValue(mockKnowledge);
-
-      const result = await executeDiscover({ topic: "git" }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as { insights: string[] };
-      expect(data.insights).toBeDefined();
-      expect(Array.isArray(data.insights)).toBe(true);
-    });
-
-    it("should preserve migrated assistant_inferred skill entries", async () => {
-      const migratedKnowledge: MockKnowledge[] = [
-        {
-          id: "migrated-skill-1",
-          name: "legacy deployment skill",
-          description: "Migrated from synthetic memory backfill",
-          tags: ["migration"],
-          source: { type: "assistant_inferred" },
-        },
-      ];
-      mockMemoria.recallTools.mockResolvedValue(migratedKnowledge);
-
-      const result = await executeDiscover({ topic: "legacy deployment" }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as {
-        tools: Array<{ source?: { type: string } }>;
-      };
-      expect(data.tools[0]?.source?.type).toBe("assistant_inferred");
-    });
-  });
-
-  describe("executeReflect", () => {
-    // ---- Input validation ----
-
-    it("should return error when summary is empty", async () => {
-      const result = await executeReflect({ summary: "" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("summary is required and cannot be empty");
-    });
-
-    it("should return error when summary is only whitespace", async () => {
-      const result = await executeReflect({ summary: "   " }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("summary is required and cannot be empty");
-    });
-
-    it("should return error when memoria is not available", async () => {
-      const ctxNoMemoria = createContext("/test/dir", undefined, {
-        router: createMockRouter() as any,
-      });
-
-      const result = await executeReflect({ summary: "test summary" }, ctxNoMemoria);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Memoria");
-    });
-
-    it("should return error when router is not available", async () => {
-      // ctx has memoria but no router
-      const result = await executeReflect({ summary: "test summary" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Router");
-    });
-
-    it("should return cancelled when abortSignal is aborted", async () => {
-      const controller = new AbortController();
-      controller.abort();
-
-      const ctxAborted = createContext("/test/dir", mockMemoria, {
-        router: createMockRouter() as any,
-        abortSignal: controller.signal,
-      });
-
-      const result = await executeReflect({ summary: "test summary" }, ctxAborted);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("cancelled");
-    });
-
-    // ---- Happy path - learned something ----
-
-    it("should store observation in beliefs network when learnedAboutSelf=true", async () => {
-      const mockRouter = createMockRouter();
-      mockRouter.chat.mockResolvedValue({
-        content:
-          '{"learnedAboutSelf": true, "observation": "I struggle with regex edge cases", "skillCandidate": null}',
-      });
-
-      const ctxWithRouter = createContext("/test/dir", mockMemoria, {
-        router: mockRouter as any,
-      });
-
-      const result = await executeReflect({ summary: "Fixed a regex bug" }, ctxWithRouter);
-
-      expect(result.success).toBe(true);
-      const data = result.data as any;
-      expect(data.learned).toBe(true);
-      expect(data.observation).toBe("I struggle with regex edge cases");
-      expect(mockMemoria.remember).toHaveBeenCalledWith("I struggle with regex edge cases", {
-        network: "beliefs",
-        importance: 0.6,
-        source: "system",
-      });
-    });
-
-    it("should include skillCandidate in output when present", async () => {
-      const mockRouter = createMockRouter();
-      mockRouter.chat.mockResolvedValue({
-        content: JSON.stringify({
-          learnedAboutSelf: true,
-          observation: "I can orchestrate multi-file refactors",
-          skillCandidate: {
-            name: "multi-file-refactor",
-            level: "advanced",
-            description: "Coordinated refactoring across multiple files",
-          },
-        }),
-      });
-
-      const ctxWithRouter = createContext("/test/dir", mockMemoria, {
-        router: mockRouter as any,
-      });
-
-      const result = await executeReflect(
-        { summary: "Refactored 5 files in a single pass" },
-        ctxWithRouter,
-      );
-
-      expect(result.success).toBe(true);
-      const data = result.data as any;
-      expect(data.learned).toBe(true);
-      expect(data.skillCandidate).toEqual({
-        name: "multi-file-refactor",
-        level: "advanced",
-        description: "Coordinated refactoring across multiple files",
-      });
-    });
-
-    // ---- Happy path - no learning ----
-
-    it("should return learned=false when learnedAboutSelf=false", async () => {
-      const mockRouter = createMockRouter();
-      mockRouter.chat.mockResolvedValue({
-        content: '{"learnedAboutSelf": false, "observation": null, "skillCandidate": null}',
-      });
-
-      const ctxWithRouter = createContext("/test/dir", mockMemoria, {
-        router: mockRouter as any,
-      });
-
-      const result = await executeReflect({ summary: "Routine code edit" }, ctxWithRouter);
-
-      expect(result.success).toBe(true);
-      const data = result.data as any;
-      expect(data.learned).toBe(false);
-      expect(data.observation).toBeNull();
-      expect(mockMemoria.remember).not.toHaveBeenCalled();
-    });
-
-    it("should return learned=false when observation is null", async () => {
-      const mockRouter = createMockRouter();
-      mockRouter.chat.mockResolvedValue({
-        content: '{"learnedAboutSelf": true, "observation": null, "skillCandidate": null}',
-      });
-
-      const ctxWithRouter = createContext("/test/dir", mockMemoria, {
-        router: mockRouter as any,
-      });
-
-      const result = await executeReflect({ summary: "Nothing notable" }, ctxWithRouter);
-
-      expect(result.success).toBe(true);
-      const data = result.data as any;
-      expect(data.learned).toBe(false);
-      expect(data.observation).toBeNull();
-      // learnedAboutSelf=true but observation=null => should NOT store
-      expect(mockMemoria.remember).not.toHaveBeenCalled();
-    });
-
-    // ---- LLM response parsing (CLAUDE.md "Mocks Must Match Reality") ----
-
-    it("should handle plain text response (no JSON)", async () => {
-      const mockRouter = createMockRouter();
-      mockRouter.chat.mockResolvedValue({
-        content: "I think the answer is yes, I learned something today.",
-      });
-
-      const ctxWithRouter = createContext("/test/dir", mockMemoria, {
-        router: mockRouter as any,
-      });
-
-      const result = await executeReflect({ summary: "Some conversation" }, ctxWithRouter);
-
-      expect(result.success).toBe(true);
-      const data = result.data as any;
-      expect(data.learned).toBe(false);
-      expect(data.observation).toBeNull();
-    });
-
-    it("should handle truncated JSON response", async () => {
-      const mockRouter = createMockRouter();
-      mockRouter.chat.mockResolvedValue({
-        content: '{"learnedAboutSelf": true, "observa',
-      });
-
-      const ctxWithRouter = createContext("/test/dir", mockMemoria, {
-        router: mockRouter as any,
-      });
-
-      const result = await executeReflect({ summary: "Truncated" }, ctxWithRouter);
-
-      expect(result.success).toBe(true);
-      const data = result.data as any;
-      expect(data.learned).toBe(false);
-      expect(data.observation).toBeNull();
-    });
-
-    it("should handle empty string response", async () => {
-      const mockRouter = createMockRouter();
-      mockRouter.chat.mockResolvedValue({ content: "" });
-
-      const ctxWithRouter = createContext("/test/dir", mockMemoria, {
-        router: mockRouter as any,
-      });
-
-      const result = await executeReflect({ summary: "Empty response" }, ctxWithRouter);
-
-      expect(result.success).toBe(true);
-      const data = result.data as any;
-      expect(data.learned).toBe(false);
-      expect(data.observation).toBeNull();
-    });
-
-    it("should handle JSON with missing fields (schema drift)", async () => {
-      const mockRouter = createMockRouter();
-      // Missing required 'learnedAboutSelf' field
-      mockRouter.chat.mockResolvedValue({
-        content: '{"observation": "something", "extra": true}',
-      });
-
-      const ctxWithRouter = createContext("/test/dir", mockMemoria, {
-        router: mockRouter as any,
-      });
-
-      const result = await executeReflect({ summary: "Schema drift" }, ctxWithRouter);
-
-      expect(result.success).toBe(true);
-      const data = result.data as any;
-      expect(data.learned).toBe(false);
-      expect(data.observation).toBeNull();
-    });
-
-    it("should handle JSON with extra/unexpected fields", async () => {
-      const mockRouter = createMockRouter();
-      mockRouter.chat.mockResolvedValue({
-        content: JSON.stringify({
-          learnedAboutSelf: true,
-          observation: "I work best with small functions",
-          skillCandidate: null,
-          unexpectedField: "should be stripped by Zod",
-          confidence: 0.95,
-        }),
-      });
-
-      const ctxWithRouter = createContext("/test/dir", mockMemoria, {
-        router: mockRouter as any,
-      });
-
-      const result = await executeReflect({ summary: "Extra fields" }, ctxWithRouter);
-
-      expect(result.success).toBe(true);
-      const data = result.data as any;
-      expect(data.learned).toBe(true);
-      expect(data.observation).toBe("I work best with small functions");
-      // Extra fields should not appear in output
-      expect(data).not.toHaveProperty("unexpectedField");
-      expect(data).not.toHaveProperty("confidence");
-    });
-
-    it("should handle JSON wrapped in markdown code fence", async () => {
-      const mockRouter = createMockRouter();
-      mockRouter.chat.mockResolvedValue({
-        content:
-          'Here is my analysis:\n```json\n{"learnedAboutSelf": true, "observation": "I need to check types more carefully", "skillCandidate": null}\n```',
-      });
-
-      const ctxWithRouter = createContext("/test/dir", mockMemoria, {
-        router: mockRouter as any,
-      });
-
-      const result = await executeReflect({ summary: "Code fence response" }, ctxWithRouter);
-
-      expect(result.success).toBe(true);
-      const data = result.data as any;
-      expect(data.learned).toBe(true);
-      expect(data.observation).toBe("I need to check types more carefully");
-    });
-
-    it("should parse the valid final JSON object when an earlier JSON snippet has wrong schema", async () => {
-      const mockRouter = createMockRouter();
-      mockRouter.chat.mockResolvedValue({
-        content: `Draft example:
-{"learnedAboutSelf":"unknown","observation":null}
-
-Final answer:
-{"learnedAboutSelf":true,"observation":"I should verify assumptions before coding","skillCandidate":null}`,
-      });
-
-      const ctxWithRouter = createContext("/test/dir", mockMemoria, {
-        router: mockRouter as any,
-      });
-
-      const result = await executeReflect({ summary: "Schema selection" }, ctxWithRouter);
-
-      expect(result.success).toBe(true);
-      const data = result.data as any;
-      expect(data.learned).toBe(true);
-      expect(data.observation).toBe("I should verify assumptions before coding");
-      expect(mockMemoria.remember).toHaveBeenCalledWith(
-        "I should verify assumptions before coding",
-        expect.any(Object),
-      );
-    });
-
-    // ---- Error propagation ----
-
-    it("should handle router.chat errors gracefully", async () => {
-      const mockRouter = createMockRouter();
-      mockRouter.chat.mockRejectedValue(new Error("Rate limit exceeded"));
-
-      const ctxWithRouter = createContext("/test/dir", mockMemoria, {
-        router: mockRouter as any,
-      });
-
-      const result = await executeReflect({ summary: "Will fail" }, ctxWithRouter);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Rate limit exceeded");
-    });
-
-    it("should handle memoria.remember errors gracefully", async () => {
-      const mockRouter = createMockRouter();
-      mockRouter.chat.mockResolvedValue({
-        content:
-          '{"learnedAboutSelf": true, "observation": "Something learned", "skillCandidate": null}',
-      });
-
-      const failingMemoria = createMockMemoria();
-      failingMemoria.remember.mockRejectedValue(new Error("SQLite write failed"));
-
-      const ctxWithRouter = createContext("/test/dir", failingMemoria, {
-        router: mockRouter as any,
-      });
-
-      const result = await executeReflect({ summary: "Memory will fail" }, ctxWithRouter);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("SQLite write failed");
-    });
-
-    // ---- Verify correct router call ----
-
-    it("should call router.chat with correct messages, temperature, and tier", async () => {
-      const mockRouter = createMockRouter();
-      mockRouter.chat.mockResolvedValue({
-        content: '{"learnedAboutSelf": false, "observation": null, "skillCandidate": null}',
-      });
-
-      const ctxWithRouter = createContext("/test/dir", mockMemoria, {
-        router: mockRouter as any,
-      });
-
-      await executeReflect({ summary: "Test conversation summary" }, ctxWithRouter);
-
-      expect(mockRouter.chat).toHaveBeenCalledTimes(1);
-      const callArgs = mockRouter.chat.mock.calls[0][0];
-      expect(callArgs.temperature).toBe(0.3);
-      expect(callArgs.tier).toBe("fast");
-      expect(callArgs.messages).toHaveLength(2);
-      expect(callArgs.messages[0].role).toBe("system");
-      expect(callArgs.messages[0].content).toContain("reflecting");
-      expect(callArgs.messages[1].role).toBe("user");
-      expect(callArgs.messages[1].content).toContain("Test conversation summary");
-      expect(callArgs.messages[1].content).toContain("learnedAboutSelf");
-    });
-  });
-});