@aria-cli/tools 1.0.8 → 1.0.10

package/tests/critical-integration.test.ts

@@ -1,1465 +0,0 @@
-/**
- * @aria/tools - Critical Integration Tests
- *
- * Tests the integration paths between:
- * - Tool registry and executor wiring (every tool has an executor)
- * - ToolContext injection (memoria, arion, manager, router)
- * - Memory executor full flow with Memoria API
- * - Arion executor full flow with ArionManager API
- * - Risk level classifications and sandbox expectations
- * - Error propagation from executor to runner
- *
- * METHODOLOGY: All tests are written to FAIL first (test-first).
- * They describe what CORRECT behavior SHOULD be.
- */
-
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import {
-  createToolRegistry,
-  CORE_TOOL_DEFINITIONS,
-  getCoreTool,
-  getCoreToolsByCategory,
-  getCoreToolsByRiskLevel,
-} from "../src/index.js";
-import { ToolRegistry } from "../src/registry/registry.js";
-import type {
-  ToolContext,
-  ToolResult,
-  Tool,
-  RiskLevel,
-  ToolCategory,
-  ArionRef,
-  ArionManagerRef,
-} from "../src/types.js";
-import {
-  executeRemember,
-  executeRecall,
-  executeForget,
-  executeDiscover,
-  executeReflect,
-} from "../src/executors/memory.js";
-import { executeHatchArion } from "../src/executors/arion.js";
-
-// ===========================================================================
-// Shared Helpers
-// ===========================================================================
-
-/** Create a mock Memoria with all methods */
-function createMockMemoria() {
-  return {
-    remember: vi.fn().mockResolvedValue({ id: "mem-test-001" }),
-    recall: vi.fn().mockResolvedValue({ memories: [] }),
-    recallTools: vi.fn().mockResolvedValue([]),
-    rememberTool: vi.fn().mockResolvedValue("knowledge-001"),
-    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().mockResolvedValue(true),
-  };
-}
-
-/** Create a mock ArionManager */
-function createMockManager(): ArionManagerRef {
-  return {
-    hatch: vi.fn().mockResolvedValue({
-      id: "arion-new-001",
-      name: "TestArion",
-      emoji: "🦅",
-    }),
-    getMemoria: vi.fn().mockResolvedValue(createMockMemoria()),
-  };
-}
-
-/** Create a base ToolContext with optional overrides */
-function createContext(overrides: Partial<ToolContext> = {}): ToolContext {
-  return {
-    workingDir: "/tmp/test-tools",
-    env: {},
-    confirm: vi.fn().mockResolvedValue(true),
-    ...overrides,
-  };
-}
-
-// ===========================================================================
-// Section 1: Registry-Executor Completeness
-// ===========================================================================
-
-describe("Registry-Executor Completeness", () => {
-  it("every CORE_TOOL_DEFINITION should have a callable execute function", () => {
-    // Verifies no tool was left with a stub/undefined executor
-    expect(CORE_TOOL_DEFINITIONS.length).toBeGreaterThan(0);
-    for (const tool of CORE_TOOL_DEFINITIONS) {
-      expect(typeof tool.execute).toBe("function");
-    }
-  });
-
-  it("createToolRegistry() should register all core tools by default", () => {
-    const registry = createToolRegistry();
-    const all = registry.getAll();
-    expect(all.length).toBe(CORE_TOOL_DEFINITIONS.length);
-
-    // Verify every core tool name is registered
-    const registeredNames = new Set(all.map((t) => t.name));
-    for (const tool of CORE_TOOL_DEFINITIONS) {
-      expect(registeredNames.has(tool.name)).toBe(true);
-    }
-  });
-
-  it("createToolRegistry({ includeBuiltins: false }) should be empty", () => {
-    const registry = createToolRegistry({ includeBuiltins: false });
-    expect(registry.getAll().length).toBe(0);
-  });
-
-  it("every tool retrieved from registry should be the same instance as in CORE_TOOL_DEFINITIONS", () => {
-    const registry = createToolRegistry();
-    for (const coreTool of CORE_TOOL_DEFINITIONS) {
-      const registeredTool = registry.get(coreTool.name);
-      expect(registeredTool).toBeDefined();
-      // Same execute function reference = same tool, not a copy
-      expect(registeredTool!.execute).toBe(coreTool.execute);
-    }
-  });
-
-  it("registry.list() by category should return correct tools for each category", () => {
-    const registry = createToolRegistry();
-    const categories: ToolCategory[] = [
-      "memory",
-      "web",
-      "filesystem",
-      "shell",
-      "messaging",
-      "meta",
-      "arion",
-    ];
-
-    for (const category of categories) {
-      const tools = registry.list(category);
-      expect(tools.length).toBe(getCoreToolsByCategory(category).length);
-    }
-  });
-
-  it("registry.has() should return true for all core tool names", () => {
-    const registry = createToolRegistry();
-    const expectedNames = [
-      "remember",
-      "recall",
-      "forget",
-      "recall_knowledge",
-      "reflect",
-      "web_search",
-      "web_fetch",
-      "browse",
-      "read_file",
-      "write_file",
-      "edit_file",
-      "glob",
-      "grep",
-      "ls",
-      "apply_patch",
-      "bash",
-      "exec",
-      "spawn",
-      "kill",
-      "write_stdin",
-      "hatch_arion",
-      "rest_arion",
-      "wake_arion",
-      "retire_arion",
-      "delegate_arion",
-      "spawn_worker",
-      "check_delegation",
-      "delegate_remote",
-      "ask_user",
-      "quest_update",
-      "quest_list",
-    ];
-
-    for (const name of expectedNames) {
-      expect(registry.has(name)).toBe(true);
-    }
-  });
-});
-
-// ===========================================================================
-// Section 2: ToolContext.memoria wiring for memory tools
-// ===========================================================================
-
-describe("ToolContext.memoria wiring for memory tools", () => {
-  const memoryToolNames = ["remember", "recall", "forget", "recall_knowledge", "reflect"];
-
-  it("all memory tools should fail gracefully when ctx.memoria is undefined", async () => {
-    const ctx = createContext(); // no memoria
-
-    for (const toolName of memoryToolNames) {
-      const tool = getCoreTool(toolName)!;
-      // Provide minimal valid input for each tool
-      const inputs: Record<string, unknown> = {
-        remember: { content: "test content" },
-        recall: { query: "test query" },
-        forget: { id: "mem-123" },
-        recall_knowledge: { topic: "test topic" },
-        reflect: { summary: "test summary" },
-      };
-
-      const result = await tool.execute(inputs[toolName], ctx);
-      expect(result.success).toBe(false);
-      expect(result.message).toMatch(/memoria|Memoria/i);
-    }
-  });
-
-  it("all memory tools should fail gracefully when ctx.memoria is null", async () => {
-    const ctx = createContext({ memoria: null as any });
-
-    for (const toolName of memoryToolNames) {
-      const tool = getCoreTool(toolName)!;
-      const inputs: Record<string, unknown> = {
-        remember: { content: "test content" },
-        recall: { query: "test query" },
-        forget: { id: "mem-123" },
-        recall_knowledge: { topic: "test topic" },
-        reflect: { summary: "test summary" },
-      };
-
-      const result = await tool.execute(inputs[toolName], ctx);
-      expect(result.success).toBe(false);
-      expect(result.message).toMatch(/memoria|Memoria/i);
-    }
-  });
-
-  it("all memory tools should fail gracefully when ctx.memoria is a partial object missing methods", async () => {
-    // Simulates a broken/incomplete Memoria injection
-    const partialMemoria = { remember: vi.fn() }; // missing recall, recallTools, deleteMemory
-    const ctx = createContext({ memoria: partialMemoria as any });
-
-    // remember might work since it has remember(), but recall/forget/recallTools should fail
-    const recallResult = await executeRecall({ query: "test" }, ctx);
-    expect(recallResult.success).toBe(false);
-
-    const forgetResult = await executeForget({ id: "mem-1" }, ctx);
-    expect(forgetResult.success).toBe(false);
-
-    const recallToolsResult = await executeDiscover({ topic: "test" }, ctx);
-    expect(recallToolsResult.success).toBe(false);
-  });
-
-  describe("executeRemember integration", () => {
-    it("should call memoria.remember with content and return the stored id", async () => {
-      const mockMemoria = createMockMemoria();
-      mockMemoria.remember.mockResolvedValue({ id: "mem-integrated-001" });
-      const ctx = createContext({ memoria: mockMemoria as any });
-
-      const result = await executeRemember(
-        {
-          content: "integration test content",
-          importance: 0.8,
-        },
-        ctx,
-      );
-
-      expect(result.success).toBe(true);
-      expect((result.data as any).id).toBe("mem-integrated-001");
-      expect(mockMemoria.remember).toHaveBeenCalledTimes(1);
-      // First arg should be the content string
-      expect(mockMemoria.remember.mock.calls[0][0]).toBe("integration test content");
-      // Second arg should contain importance (tags have been removed)
-      const options = mockMemoria.remember.mock.calls[0][1];
-      expect(options.importance).toBe(0.8);
-    });
-
-    it("should propagate memoria errors as failed ToolResult, not throw", async () => {
-      const mockMemoria = createMockMemoria();
-      mockMemoria.remember.mockRejectedValue(new Error("SQLite constraint violation"));
-      const ctx = createContext({ memoria: mockMemoria as any });
-
-      const result = await executeRemember({ content: "will fail" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("SQLite constraint violation");
-      // Should NOT throw - error is caught and returned as ToolResult
-    });
-  });
-
-  describe("executeRecall integration", () => {
-    it("should call memoria.recall with query and limit, return memories", async () => {
-      const mockMemoria = createMockMemoria();
-      const fakeMemories = [
-        { id: "m1", content: "fact 1" },
-        { id: "m2", content: "fact 2" },
-      ];
-      mockMemoria.recall.mockResolvedValue({ memories: fakeMemories });
-      const ctx = createContext({ memoria: mockMemoria as any });
-
-      const result = await executeRecall({ query: "facts", limit: 5 }, ctx);
-
-      expect(result.success).toBe(true);
-      expect((result.data as any).memories).toEqual(fakeMemories);
-      expect((result.data as any).count).toBe(2);
-      expect(mockMemoria.recall).toHaveBeenCalledWith(
-        "facts",
-        expect.objectContaining({ limit: 5 }),
-      );
-    });
-
-    it("should default limit to 10 when not provided", async () => {
-      const mockMemoria = createMockMemoria();
-      const ctx = createContext({ memoria: mockMemoria as any });
-
-      await executeRecall({ query: "test" }, ctx);
-
-      expect(mockMemoria.recall).toHaveBeenCalledWith(
-        "test",
-        expect.objectContaining({ limit: 10 }),
-      );
-    });
-  });
-
-  describe("executeForget integration", () => {
-    it("should call memoria.deleteMemory and return deleted status", async () => {
-      const mockMemoria = createMockMemoria();
-      mockMemoria.deleteMemory.mockResolvedValue(true);
-      const ctx = createContext({ memoria: mockMemoria as any });
-
-      const result = await executeForget({ id: "mem-to-delete" }, ctx);
-
-      expect(result.success).toBe(true);
-      expect((result.data as any).deleted).toBe(true);
-      expect((result.data as any).id).toBe("mem-to-delete");
-      expect(mockMemoria.deleteMemory).toHaveBeenCalledWith("mem-to-delete");
-    });
-
-    it("should return failure when memory does not exist", async () => {
-      const mockMemoria = createMockMemoria();
-      mockMemoria.deleteMemory.mockResolvedValue(false);
-      const ctx = createContext({ memoria: mockMemoria as any });
-
-      const result = await executeForget({ id: "nonexistent" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("not found");
-    });
-  });
-
-  describe("executeDiscover integration", () => {
-    it("should call memoria.recallTools and generate insights", async () => {
-      const mockMemoria = createMockMemoria();
-      const fakeKnowledge = [
-        {
-          id: "k1",
-          name: "file_reader",
-          description: "Reads files",
-        },
-        {
-          id: "k2",
-          name: "debugging",
-          description: "Debug skills",
-        },
-      ];
-      mockMemoria.recallTools.mockResolvedValue(fakeKnowledge);
-      mockMemoria.recallSkills.mockResolvedValue([]);
-      const ctx = createContext({ memoria: mockMemoria as any });
-
-      const result = await executeDiscover({ topic: "file operations" }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as any;
-      expect(data.toolCount).toBe(2);
-      expect(data.tools).toEqual(fakeKnowledge);
-      expect(data.insights).toBeDefined();
-      expect(Array.isArray(data.insights)).toBe(true);
-      expect(data.insights.length).toBeGreaterThan(0);
-
-      // Should call recallTools (both tools and skills fetched without kind)
-      expect(mockMemoria.recallTools).toHaveBeenCalledWith({
-        query: "file operations",
-        limit: 10,
-      });
-    });
-  });
-
-  describe("executeReflect integration", () => {
-    it("should call router.chat and store observation when learned", async () => {
-      const mockMemoria = createMockMemoria();
-      const mockRouter = {
-        chat: vi.fn().mockResolvedValue({
-          content:
-            '{"learnedAboutSelf": true, "observation": "I struggle with edge cases in regex", "skillCandidate": null}',
-        }),
-      };
-      const ctx = createContext({ memoria: mockMemoria as any, router: mockRouter as any });
-
-      const result = await executeReflect({ summary: "Fixed a regex bug" }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as any;
-      expect(data.learned).toBe(true);
-      expect(data.observation).toContain("regex");
-      expect(mockMemoria.remember).toHaveBeenCalledWith(
-        expect.stringContaining("regex"),
-        expect.objectContaining({ network: "beliefs" }),
-      );
-    });
-
-    it("should fail gracefully when router is undefined", async () => {
-      const mockMemoria = createMockMemoria();
-      const ctx = createContext({ memoria: mockMemoria as any });
-      // no router
-
-      const result = await executeReflect({ summary: "test" }, ctx);
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Router");
-    });
-  });
-});
-
-// ===========================================================================
-// Section 3: ToolContext.arion and ToolContext.manager wiring for arion tools
-// ===========================================================================
-
-describe("ToolContext.arion and ToolContext.manager wiring", () => {
-  const validInput = {
-    name: "TestArion",
-    traits: ["curious", "brave"],
-    style: "casual" as const,
-    emoji: "🦅",
-  };
-
-  it("hatch_arion should fail when ctx.manager is undefined", async () => {
-    const ctx = createContext({
-      arion: { id: "parent-1", name: "Parent", emoji: "🐣" },
-      // manager not set
-    });
-
-    const result = await executeHatchArion(validInput, ctx);
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("ArionManager");
-  });
-
-  it("hatch_arion should fail when ctx.arion is undefined", async () => {
-    const ctx = createContext({
-      manager: createMockManager(),
-      // arion not set
-    });
-
-    const result = await executeHatchArion(validInput, ctx);
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("arion context");
-  });
-
-  it("hatch_arion should call ctx.confirm before creating", async () => {
-    const confirmFn = vi.fn().mockResolvedValue(true);
-    const mockManager = createMockManager();
-    const ctx = createContext({
-      arion: { id: "parent-1", name: "Parent", emoji: "🐣" },
-      manager: mockManager,
-      confirm: confirmFn,
-    });
-
-    await executeHatchArion(validInput, ctx);
-
-    expect(confirmFn).toHaveBeenCalledTimes(1);
-    // Confirm message should include the arion name and traits
-    const confirmMsg = confirmFn.mock.calls[0][0] as string;
-    expect(confirmMsg).toContain("TestArion");
-    expect(confirmMsg).toContain("curious");
-  });
-
-  it("hatch_arion should return failure when user cancels confirmation", async () => {
-    const ctx = createContext({
-      arion: { id: "parent-1", name: "Parent", emoji: "🐣" },
-      manager: createMockManager(),
-      confirm: vi.fn().mockResolvedValue(false), // User cancels
-    });
-
-    const result = await executeHatchArion(validInput, ctx);
-
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("cancelled");
-  });
-
-  it("hatch_arion should call manager.hatch with correct config", async () => {
-    const mockManager = createMockManager();
-    const ctx = createContext({
-      arion: { id: "parent-1", name: "Parent", emoji: "🐣" },
-      manager: mockManager,
-    });
-
-    const result = await executeHatchArion(validInput, ctx);
-
-    expect(result.success).toBe(true);
-    expect(mockManager.hatch).toHaveBeenCalledTimes(1);
-    const hatchConfig = (mockManager.hatch as ReturnType<typeof vi.fn>).mock.calls[0][0];
-    expect(hatchConfig.name).toBe("TestArion");
-    expect(hatchConfig.personality.traits).toEqual(["curious", "brave"]);
-    expect(hatchConfig.personality.style).toBe("casual");
-    expect(hatchConfig.createdBy).toBe("Parent");
-  });
-
-  it("hatch_arion should seed beliefs into new arion memory when provided", async () => {
-    const newArionMemoria = createMockMemoria();
-    const mockManager: any = {
-      hatch: vi.fn().mockResolvedValue({
-        id: "arion-new",
-        name: "NewArion",
-        emoji: "🦅",
-      }),
-      getMemoria: vi.fn().mockResolvedValue(newArionMemoria),
-    };
-    const ctx = createContext({
-      arion: { id: "parent-1", name: "Parent", emoji: "🐣" },
-      manager: mockManager,
-    });
-
-    const inputWithBeliefs = {
-      ...validInput,
-      beliefs: ["I am curious", "I value truth"],
-    };
-
-    const result = await executeHatchArion(inputWithBeliefs, ctx);
-
-    expect(result.success).toBe(true);
-    // getMemoria should be called for the new arion
-    expect(mockManager.getMemoria).toHaveBeenCalledWith(
-      expect.objectContaining({ id: "arion-new" }),
-    );
-    // Each belief should be stored via remember
-    expect(newArionMemoria.remember).toHaveBeenCalledTimes(2);
-    expect(newArionMemoria.remember).toHaveBeenCalledWith("I am curious", {
-      network: "beliefs",
-    });
-    expect(newArionMemoria.remember).toHaveBeenCalledWith("I value truth", {
-      network: "beliefs",
-    });
-  });
-
-  it("hatch_arion should propagate manager.hatch errors as ToolResult", async () => {
-    const mockManager: any = {
-      hatch: vi.fn().mockRejectedValue(new Error("Arion limit reached")),
-      getMemoria: vi.fn(),
-    };
-    const ctx = createContext({
-      arion: { id: "parent-1", name: "Parent", emoji: "🐣" },
-      manager: mockManager,
-    });
-
-    const result = await executeHatchArion(validInput, ctx);
-
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("Arion limit reached");
-  });
-
-  it("hatch_arion should return the new arion id, name, and emoji", async () => {
-    const mockManager = createMockManager();
-    const ctx = createContext({
-      arion: { id: "parent-1", name: "Parent", emoji: "🐣" },
-      manager: mockManager,
-    });
-
-    const result = await executeHatchArion(validInput, ctx);
-
-    expect(result.success).toBe(true);
-    expect(result.data).toEqual({
-      arionId: "arion-new-001",
-      name: "TestArion",
-      emoji: "🦅",
-    });
-  });
-});
-
-// ===========================================================================
-// Section 4: ToolContext.manager wiring gap (CRITICAL BUG)
-// ===========================================================================
-
-describe("ToolContext.manager wiring from AgentRunner", () => {
-  /**
-   * CRITICAL: AgentRunner at runner.ts:1547-1556 builds ToolContext but
-   * does NOT include `manager` in the context object. This means
-   * hatch_arion will ALWAYS fail at runtime because ctx.manager is undefined.
-   *
-   * The runner builds:
-   *   const ctx: ToolContext = {
-   *     workingDir, env, memoria, arion, router, confirm, abortSignal, context
-   *   }
-   *
-   * Missing: manager
-   *
-   * This test documents the expected behavior that should be implemented.
-   */
-  it("AgentRunner should inject manager into ToolContext when options.manager is provided", () => {
-    // This is a documentation test - the actual fix needs to happen in runner.ts
-    // When the runner builds ToolContext, it should include:
-    //   manager: options?.manager as any,
-    //
-    // This test asserts the expected shape of ToolContext
-    const ctx = createContext({
-      manager: createMockManager(),
-    });
-
-    expect(ctx.manager).toBeDefined();
-    expect(typeof ctx.manager!.hatch).toBe("function");
-    expect(typeof ctx.manager!.getMemoria).toBe("function");
-  });
-
-  it("hatch_arion tool from registry should work end-to-end when manager is in context", async () => {
-    const registry = createToolRegistry();
-    const tool = registry.get("hatch_arion");
-    expect(tool).toBeDefined();
-    expect(tool!.category).toBe("arion");
-
-    const mockManager = createMockManager();
-    const ctx = createContext({
-      arion: { id: "parent", name: "Parent", emoji: "🐣" },
-      manager: mockManager,
-    });
-
-    const result = await tool!.execute(
-      {
-        name: "RegistryTestArion",
-        traits: ["smart"],
-        style: "technical",
-      },
-      ctx,
-    );
-
-    expect(result.success).toBe(true);
-    expect(mockManager.hatch).toHaveBeenCalled();
-  });
-});
-
-// ===========================================================================
-// Section 5: Tool safety / riskLevel classification correctness
-// ===========================================================================
-
-describe("Tool riskLevel classifications", () => {
-  it("selected read-only tools should be classified as 'safe'", () => {
-    const expectedSafe = [
-      "recall",
-      "recall_knowledge",
-      "web_fetch",
-      "browse",
-      "read_file",
-      "glob",
-      "grep",
-      "ls",
-      // "search" moved to @aria/aria
-    ];
-    for (const name of expectedSafe) {
-      const tool = getCoreTool(name);
-      expect(tool).toBeDefined();
-      expect(tool!.riskLevel).toBe("safe");
-      expect(tool!.isReadOnly).toBe(true);
-    }
-  });
-
-  it("destructive tools should be classified as 'dangerous'", () => {
-    const expectedDangerous = [
-      "forget",
-      "write_file",
-      "edit_file",
-      "apply_patch",
-      "bash",
-      "exec",
-      "spawn",
-      "kill",
-      "hatch_arion",
-      "retire_arion",
-    ];
-    for (const name of expectedDangerous) {
-      const tool = getCoreTool(name);
-      expect(tool).toBeDefined();
-      expect(tool!.riskLevel).toBe("dangerous");
-    }
-  });
-
-  it("moderate-risk tools should be classified as 'moderate'", () => {
-    const expectedModerate = [
-      "remember",
-      "reflect",
-      "web_search",
-      "delegate_arion",
-      "delegate_remote",
-      "rest_arion",
-      "wake_arion",
-      "ask_user",
-      "quest_update",
-      "spawn_worker",
-      "write_stdin",
-    ];
-    for (const name of expectedModerate) {
-      const tool = getCoreTool(name);
-      expect(tool).toBeDefined();
-      expect(tool!.riskLevel).toBe("moderate");
-    }
-  });
-
-  it("tools with requiresConfirmation should have dangerous riskLevel", () => {
-    // Tools that explicitly set requiresConfirmation: true should be dangerous
-    const toolsRequiringConfirmation = CORE_TOOL_DEFINITIONS.filter(
-      (t) => t.requiresConfirmation === true,
-    );
-    expect(toolsRequiringConfirmation.length).toBeGreaterThan(0);
-    for (const tool of toolsRequiringConfirmation) {
-      expect(tool.riskLevel).toBe("dangerous");
-    }
-  });
-
-  it("dangerous tools without explicit requiresConfirmation should default to requiring it", () => {
-    // The ToolInfo conversion in registry should treat dangerous as requiresConfirmation=true
-    const registry = createToolRegistry();
-    const infos = registry.getToolInfos();
-
-    for (const info of infos) {
-      const tool = getCoreTool(info.name);
-      if (tool && tool.riskLevel === "dangerous") {
-        expect(info.requiresConfirmation).toBe(true);
-      }
-    }
-  });
-
-  it("all tools should have valid category values", () => {
-    const validCategories: ToolCategory[] = [
-      "filesystem",
-      "code",
-      "shell",
-      "web",
-      "data",
-      "memory",
-      "arion",
-      "messaging",
-      "meta",
-    ];
-    for (const tool of CORE_TOOL_DEFINITIONS) {
-      expect(validCategories).toContain(tool.category);
-    }
-  });
-
-  it("all tools should have valid riskLevel values", () => {
-    const validRiskLevels: RiskLevel[] = ["safe", "moderate", "dangerous"];
-    for (const tool of CORE_TOOL_DEFINITIONS) {
-      expect(validRiskLevels).toContain(tool.riskLevel);
-    }
-  });
-
-  it("getCoreToolsByRiskLevel should return correct counts", () => {
-    const safeTools = getCoreToolsByRiskLevel("safe");
-    const moderateTools = getCoreToolsByRiskLevel("moderate");
-    const dangerousTools = getCoreToolsByRiskLevel("dangerous");
-
-    expect(safeTools.length + moderateTools.length + dangerousTools.length).toBe(
-      CORE_TOOL_DEFINITIONS.length,
-    );
-
-    // Verify known counts based on the tool definitions
-    expect(safeTools.length).toBeGreaterThanOrEqual(9); // read_file, recall, recall_knowledge, web_fetch, browse, glob, grep, ls, check_delegation, quest_list
-    expect(dangerousTools.length).toBeGreaterThanOrEqual(10); // forget, write_file, edit_file, apply_patch, bash, exec, spawn, kill, hatch_arion, retire_arion
-    expect(moderateTools.length).toBeGreaterThanOrEqual(9); // remember, reflect, web_search, delegate_arion, rest_arion, wake_arion, ask_user, quest_update, spawn_worker, write_stdin
-  });
-});
-
-// Section 6: Meta tools (search/learn) — moved to @aria/aria.
-// Tests for these tools live in @aria/aria tests now.
-
-// ===========================================================================
-// Section 7: Error handling - executor throws should yield tool_result error
-// ===========================================================================
-
-describe("Error handling: executor throws yield proper ToolResult errors", () => {
-  it("remember executor should catch and return ToolResult on unexpected error", async () => {
-    const brokenMemoria = {
-      remember: vi.fn().mockImplementation(() => {
-        throw new TypeError("Cannot read properties of undefined");
-      }),
-      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(),
-    };
-    const ctx = createContext({ memoria: brokenMemoria as any });
-
-    // Should NOT throw - should return a failed ToolResult
-    const result = await executeRemember({ content: "test" }, ctx);
-    expect(result.success).toBe(false);
-    expect(result.message).toBeDefined();
-  });
-
-  it("recall executor should catch and return ToolResult on unexpected error", async () => {
-    const brokenMemoria = {
-      remember: vi.fn(),
-      recall: vi.fn().mockImplementation(() => {
-        throw new Error("Connection refused");
-      }),
-      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(),
-    };
-    const ctx = createContext({ memoria: brokenMemoria as any });
-
-    const result = await executeRecall({ query: "test" }, ctx);
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("Connection refused");
-  });
-
-  it("forget executor should catch and return ToolResult on unexpected error", async () => {
-    const brokenMemoria = {
-      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().mockRejectedValue(new Error("Disk full")),
-    };
-    const ctx = createContext({ memoria: brokenMemoria as any });
-
-    const result = await executeForget({ id: "mem-123" }, ctx);
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("Disk full");
-  });
-
-  it("recallTools executor should degrade gracefully when one store errors", async () => {
-    const brokenMemoria = {
-      remember: vi.fn(),
-      recall: vi.fn(),
-      recallTools: vi.fn().mockRejectedValue(new Error("Embedding service down")),
-      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(),
-    };
-    const ctx = createContext({ memoria: brokenMemoria as any });
-
-    const result = await executeDiscover({ topic: "test" }, ctx);
-    expect(result.success).toBe(true);
-    const data = result.data as { tools: unknown[]; skills: unknown[]; toolCount: number };
-    expect(data.tools).toEqual([]);
-    expect(data.toolCount).toBe(0);
-    expect(Array.isArray(data.skills)).toBe(true);
-  });
-
-  it("hatch_arion should not throw when manager.hatch throws", async () => {
-    const mockManager: any = {
-      hatch: vi.fn().mockRejectedValue(new Error("Internal error")),
-      getMemoria: vi.fn(),
-    };
-    const ctx = createContext({
-      arion: { id: "parent", name: "Parent", emoji: "🐣" },
-      manager: mockManager,
-    });
-
-    // Should NOT throw
-    const result = await executeHatchArion({ name: "Test", traits: ["a"], style: "casual" }, ctx);
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("Internal error");
-  });
-});
-
-// ===========================================================================
-// Section 8: Registry getToolInfos - ToolInfo correctness
-// ===========================================================================
-
-describe("Registry getToolInfos correctness", () => {
-  it("getToolInfos should return info for all core tools", () => {
-    const registry = createToolRegistry();
-    const infos = registry.getToolInfos();
-    expect(infos.length).toBe(CORE_TOOL_DEFINITIONS.length);
-  });
-
-  it("each ToolInfo should have name, description, and parameters", () => {
-    const registry = createToolRegistry();
-    const infos = registry.getToolInfos();
-
-    for (const info of infos) {
-      expect(info.name).toBeDefined();
-      expect(typeof info.name).toBe("string");
-      expect(info.name.length).toBeGreaterThan(0);
-
-      expect(info.description).toBeDefined();
-      expect(typeof info.description).toBe("string");
-      expect(info.description.length).toBeGreaterThan(0);
-
-      expect(info.parameters).toBeDefined();
-      expect(Array.isArray(info.parameters)).toBe(true);
-    }
-  });
-
-  it("ToolInfo.parameters should list required parameters as required=true", () => {
-    const registry = createToolRegistry();
-    const infos = registry.getToolInfos();
-
-    // remember has required: ["content"]
-    const rememberInfo = infos.find((i) => i.name === "remember")!;
-    const contentParam = rememberInfo.parameters.find((p) => p.name === "content");
-    expect(contentParam).toBeDefined();
-    expect(contentParam!.required).toBe(true);
-
-    // Tags have been removed from remember schema
-    const tagsParam = rememberInfo.parameters.find((p) => p.name === "tags");
-    expect(tagsParam).toBeUndefined();
-  });
-});
-
-// ===========================================================================
-// Section 9: Memoria-discovered tools (dynamic tool loading)
-// ===========================================================================
-
-describe("Memoria-discovered tool execution", () => {
-  it("discovered tool with responseTemplate should interpolate input values", async () => {
-    const registry = new ToolRegistry();
-    const mockMemoria = {
-      recallTools: vi.fn().mockResolvedValue([
-        {
-          id: "k1",
-          name: "greet_user",
-          description: "Greet a user by name",
-          category: "meta",
-          parameters: {
-            type: "object",
-            properties: { name: { type: "string" } },
-            required: ["name"],
-          },
-          riskLevel: "safe",
-          responseTemplate: "Hello, {{name}}! Welcome to ARIA.",
-        },
-      ]),
-      rememberTool: 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() }),
-    };
-
-    const count = await registry.discoverFromMemoria(mockMemoria as any);
-    expect(count).toBe(1);
-
-    const tool = registry.get("greet_user")!;
-    const ctx = createContext();
-    const result = await tool.execute({ name: "Alice" }, ctx);
-
-    expect(result.success).toBe(true);
-    expect(result.data).toBe("Hello, Alice! Welcome to ARIA.");
-  });
-
-  it("knowledge-only discovered tool should be skipped", async () => {
-    const registry = new ToolRegistry();
-    const mockMemoria = {
-      recallTools: vi.fn().mockResolvedValue([
-        {
-          id: "k2",
-          name: "explain_concept",
-          description: "Explains a concept",
-          category: "meta",
-          parameters: { type: "object", properties: {} },
-          riskLevel: "safe",
-          knowledge:
-            "Neural networks are computing systems inspired by biological neural networks.",
-        },
-      ]),
-      rememberTool: 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() }),
-    };
-
-    const count = await registry.discoverFromMemoria(mockMemoria as any);
-    expect(count).toBe(0);
-    expect(registry.get("explain_concept")).toBeUndefined();
-  });
-
-  it("discovered tool should validate required parameters", async () => {
-    const registry = new ToolRegistry();
-    const mockMemoria = {
-      recallTools: vi.fn().mockResolvedValue([
-        {
-          id: "k3",
-          name: "requires_input",
-          description: "Tool needing input",
-          category: "meta",
-          parameters: {
-            type: "object",
-            properties: { input: { type: "string" } },
-            required: ["input"],
-          },
-          riskLevel: "safe",
-          responseTemplate: "Got: {{input}}",
-        },
-      ]),
-      rememberTool: 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() }),
-    };
-
-    await registry.discoverFromMemoria(mockMemoria as any);
-
-    const tool = registry.get("requires_input")!;
-    const ctx = createContext();
-    // Missing required "input" parameter
-    const result = await tool.execute({}, ctx);
-
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("input");
-  });
-
-  it("discovered tools should NOT override existing core tools", async () => {
-    const registry = new ToolRegistry();
-    // Register a core tool first
-    const coreTool = getCoreTool("remember")!;
-    registry.register(coreTool);
-
-    const mockMemoria = {
-      recallTools: vi.fn().mockResolvedValue([
-        {
-          id: "k4",
-          name: "remember", // Same name as core tool
-          description: "Fake remember",
-          category: "memory",
-          riskLevel: "safe",
-        },
-      ]),
-      rememberTool: 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() }),
-    };
-
-    const count = await registry.discoverFromMemoria(mockMemoria as any);
-    expect(count).toBe(0); // Should NOT add it since "remember" already exists
-
-    // Original tool should still be there
-    const tool = registry.get("remember")!;
-    expect(tool.execute).toBe(coreTool.execute);
-  });
-});
-
-// ===========================================================================
-// Section 10: Registry registration edge cases
-// ===========================================================================
-
-describe("Registry registration edge cases", () => {
-  it("register should throw when tool already exists without override flag", () => {
-    const registry = new ToolRegistry();
-    const tool: Tool = {
-      name: "test_tool",
-      description: "Test",
-      category: "meta",
-      parameters: { type: "object", properties: {} },
-      riskLevel: "safe",
-      execute: async () => ({ success: true, message: "ok" }),
-    };
-
-    registry.register(tool);
-
-    expect(() => registry.register(tool)).toThrow("already registered");
-  });
-
-  it("register should succeed with override flag", () => {
-    const registry = new ToolRegistry();
-    const tool: Tool = {
-      name: "test_tool",
-      description: "Original",
-      category: "meta",
-      parameters: { type: "object", properties: {} },
-      riskLevel: "safe",
-      execute: async () => ({ success: true, message: "original" }),
-    };
-    const replacement: Tool = {
-      ...tool,
-      description: "Replaced",
-      execute: async () => ({ success: true, message: "replaced" }),
-    };
-
-    registry.register(tool);
-    registry.register(replacement, { override: true });
-
-    const result = registry.get("test_tool");
-    expect(result!.description).toBe("Replaced");
-  });
-
-  it("unregister should remove tool and return true", () => {
-    const registry = new ToolRegistry();
-    const tool: Tool = {
-      name: "removable",
-      description: "Can be removed",
-      category: "meta",
-      parameters: { type: "object", properties: {} },
-      riskLevel: "safe",
-      execute: async () => ({ success: true, message: "ok" }),
-    };
-
-    registry.register(tool);
-    expect(registry.has("removable")).toBe(true);
-
-    const removed = registry.unregister("removable");
-    expect(removed).toBe(true);
-    expect(registry.has("removable")).toBe(false);
-  });
-
-  it("unregister should return false for non-existent tool", () => {
-    const registry = new ToolRegistry();
-    const removed = registry.unregister("nonexistent");
-    expect(removed).toBe(false);
-  });
-
-  it("clear should remove all tools", () => {
-    const registry = createToolRegistry();
-    expect(registry.getAll().length).toBe(CORE_TOOL_DEFINITIONS.length);
-
-    registry.clear();
-    expect(registry.getAll().length).toBe(0);
-  });
-
-  it("search should find tools by name or description substring", () => {
-    const registry = createToolRegistry();
-
-    const fileTools = registry.search("file");
-    expect(fileTools.length).toBeGreaterThanOrEqual(3); // read_file, write_file, edit_file
-
-    const memoryTools = registry.search("memory");
-    expect(memoryTools.length).toBeGreaterThanOrEqual(1);
-  });
-});
-
-// ===========================================================================
-// Section 11: ToolContext.abortSignal propagation
-// ===========================================================================
-
-describe("ToolContext.abortSignal propagation", () => {
-  it("MCP tools should check abortSignal before executing", async () => {
-    // This tests the MCP tool wrapper pattern in registry.ts
-    // MCP tools created by connectMCP check ctx.abortSignal?.aborted
-    const controller = new AbortController();
-    controller.abort();
-
-    const ctx = createContext({ abortSignal: controller.signal });
-    expect(ctx.abortSignal?.aborted).toBe(true);
-
-    // Core tools don't currently check abortSignal, but the infrastructure
-    // should support it. This test validates the context shape is correct.
-  });
-});
-
-// ===========================================================================
-// Section 12: Tool isReadOnly classification correctness
-// ===========================================================================
-
-describe("Tool isReadOnly classification", () => {
-  it("read-only tools should have isReadOnly: true", () => {
-    const expectedReadOnly = [
-      "recall",
-      "recall_knowledge",
-      "web_search",
-      "web_fetch",
-      "browse",
-      "read_file",
-      "glob",
-      "grep",
-      "ls",
-      // "search" moved to @aria/aria
-    ];
-
-    for (const name of expectedReadOnly) {
-      const tool = getCoreTool(name);
-      expect(tool).toBeDefined();
-      expect(tool!.isReadOnly).toBe(true);
-    }
-  });
-
-  it("mutating tools should have isReadOnly: false or undefined", () => {
-    const expectedMutating = [
-      "remember",
-      "reflect",
-      "forget",
-      "write_file",
-      "edit_file",
-      "apply_patch",
-      "bash",
-      "exec",
-      "spawn",
-      "kill",
-      "write_stdin",
-      "hatch_arion",
-      "rest_arion",
-      "wake_arion",
-      "retire_arion",
-      "delegate_arion",
-      "delegate_remote",
-      "spawn_worker",
-      "quest_update",
-    ];
-
-    for (const name of expectedMutating) {
-      const tool = getCoreTool(name);
-      expect(tool).toBeDefined();
-      expect(tool!.isReadOnly).not.toBe(true);
-    }
-  });
-});
-
-// ===========================================================================
-// Section 13: FAILING - Missing arion lifecycle tools (rest/wake/retire)
-// ===========================================================================
-
-describe("FAILING: Arion lifecycle tools completeness", () => {
-  /**
-   * The arion lifecycle requires 4 operations:
-   * - hatch: Create a new arion (EXISTS)
-   * - rest: Put an arion to sleep (MISSING)
-   * - wake: Wake a sleeping arion (MISSING)
-   * - retire: Permanently retire an arion (MISSING)
-   *
-   * These tools are documented in the ArionManagerRef interface but
-   * no corresponding tool definitions or executors exist.
-   */
-
-  it("should have a rest_arion tool in CORE_TOOL_DEFINITIONS", () => {
-    const tool = getCoreTool("rest_arion");
-    expect(tool).toBeDefined();
-    expect(tool!.category).toBe("arion");
-    expect(tool!.riskLevel).toBe("moderate");
-  });
-
-  it("should have a wake_arion tool in CORE_TOOL_DEFINITIONS", () => {
-    const tool = getCoreTool("wake_arion");
-    expect(tool).toBeDefined();
-    expect(tool!.category).toBe("arion");
-    expect(tool!.riskLevel).toBe("moderate");
-  });
-
-  it("should have a retire_arion tool in CORE_TOOL_DEFINITIONS", () => {
-    const tool = getCoreTool("retire_arion");
-    expect(tool).toBeDefined();
-    expect(tool!.category).toBe("arion");
-    expect(tool!.riskLevel).toBe("dangerous");
-  });
-
-  it("registry should stay aligned with the authoritative arion tool set", () => {
-    const registry = createToolRegistry();
-    const arionTools = registry.list("arion" as ToolCategory);
-    expect(arionTools.length).toBe(getCoreToolsByCategory("arion").length);
-    const names = arionTools.map((t) => t.name).sort();
-    expect(names).toEqual(
-      getCoreToolsByCategory("arion")
-        .map((tool) => tool.name)
-        .sort(),
-    );
-    expect(names).toEqual(
-      expect.arrayContaining([
-        "delegate_arion",
-        "deploy",
-        "hatch_arion",
-        "list_clients",
-        "manage_network",
-        "rest_arion",
-        "retire_arion",
-        "wake_arion",
-      ]),
-    );
-  });
-});
-
-// ===========================================================================
-// Section 14: FAILING - Core executors should respect abortSignal
-// ===========================================================================
-
-describe("FAILING: Core executors should respect abortSignal", () => {
-  /**
-   * Currently only MCP tool wrappers (created in registry.ts connectMCP)
-   * check ctx.abortSignal before executing. Core executors like
-   * remember, recall, bash, etc. do NOT check abortSignal at all.
-   *
-   * If a run is cancelled, long-running tools (bash, spawn, web_fetch)
-   * should respect the signal and abort early.
-   */
-
-  it("executeRemember should check abortSignal before calling memoria", async () => {
-    const controller = new AbortController();
-    controller.abort(); // Pre-abort
-
-    const mockMemoria = createMockMemoria();
-    const ctx = createContext({
-      memoria: mockMemoria as any,
-      abortSignal: controller.signal,
-    });
-
-    const result = await executeRemember({ content: "should not store" }, ctx);
-
-    // Should fail because signal is already aborted
-    expect(result.success).toBe(false);
-    expect(result.message).toMatch(/abort|cancel/i);
-    // Should NOT have called memoria.remember
-    expect(mockMemoria.remember).not.toHaveBeenCalled();
-  });
-
-  it("executeRecall should check abortSignal before calling memoria", async () => {
-    const controller = new AbortController();
-    controller.abort();
-
-    const mockMemoria = createMockMemoria();
-    const ctx = createContext({
-      memoria: mockMemoria as any,
-      abortSignal: controller.signal,
-    });
-
-    const result = await executeRecall({ query: "test" }, ctx);
-
-    expect(result.success).toBe(false);
-    expect(result.message).toMatch(/abort|cancel/i);
-    expect(mockMemoria.recall).not.toHaveBeenCalled();
-  });
-});
-
-// ===========================================================================
-// Section 15: FAILING - ToolContext.manager should be in RunOptions interface
-// ===========================================================================
-
-describe("FAILING: RunOptions should expose manager for ToolContext injection", () => {
-  /**
-   * AgentRunner at runner.ts:1547-1556 builds ToolContext but does NOT
-   * inject `manager` from options. The RunOptions type needs a `manager`
-   * field, and the ToolContext construction needs to wire it:
-   *
-   *   const ctx: ToolContext = {
-   *     ...
-   *     manager: options?.manager as any,  // <-- MISSING
-   *   };
-   *
-   * Without this, hatch_arion always fails at runtime.
-   */
-
-  it("ToolContext type should include optional manager field", () => {
-    // This passes (manager is on ToolContext interface)
-    const ctx = createContext({
-      manager: createMockManager(),
-    });
-    expect(ctx.manager).toBeDefined();
-  });
-
-  it("hatch_arion through full registry path should work with proper context", async () => {
-    const registry = createToolRegistry();
-    const tool = registry.get("hatch_arion");
-    expect(tool).toBeDefined();
-
-    // Simulate what the runner SHOULD build
-    const mockManager = createMockManager();
-    const ctx = createContext({
-      arion: { id: "p1", name: "Parent", emoji: "🐣" },
-      manager: mockManager,
-    });
-
-    const result = await tool!.execute(
-      { name: "NewArion", traits: ["smart"], style: "technical" },
-      ctx,
-    );
-
-    expect(result.success).toBe(true);
-    // This works when manager is manually wired, but AgentRunner doesn't wire it
-  });
-});
-
-// ===========================================================================
-// Section 16: Registry population should stay aligned with authoritative definitions
-// ===========================================================================
-
-describe("FAILING: Total tool count should reflect complete arion lifecycle", () => {
-  it("CORE_TOOL_DEFINITIONS should remain the authoritative source for registry population", () => {
-    expect(CORE_TOOL_DEFINITIONS.length).toBeGreaterThan(0);
-  });
-
-  it("createToolRegistry should register every authoritative core tool", () => {
-    const registry = createToolRegistry();
-    expect(registry.getAll().length).toBe(CORE_TOOL_DEFINITIONS.length);
-  });
-});
-
-// ===========================================================================
-// Section 17: FAILING - Meta tools with Memoria should work through registry
-// ===========================================================================
-
-// Section 17: Meta tools (search/learn) moved to @aria/aria.
-
-// ===========================================================================
-// Section 18: FAILING - Concurrent tool execution safety
-// ===========================================================================
-
-describe("FAILING: Concurrent execution safety for read-only tools", () => {
-  /**
-   * Read-only tools (isReadOnly: true) should be safe for parallel
-   * execution by the runner. This means they should not share mutable
-   * state and should not interfere with each other.
-   *
-   * The runner dispatches read-only tools in parallel, so they MUST
-   * handle concurrent calls correctly.
-   */
-
-  it("multiple concurrent recall calls should not interfere", async () => {
-    const mockMemoria = createMockMemoria();
-    let callCount = 0;
-    mockMemoria.recall.mockImplementation(async (query: string) => {
-      callCount++;
-      const myCount = callCount;
-      // Simulate async delay
-      await new Promise((r) => setTimeout(r, 10));
-      return { memories: [{ id: `mem-${myCount}`, content: `Result for: ${query}` }] };
-    });
-    const ctx = createContext({ memoria: mockMemoria as any });
-
-    // Launch 3 concurrent recalls
-    const [r1, r2, r3] = await Promise.all([
-      executeRecall({ query: "alpha" }, ctx),
-      executeRecall({ query: "beta" }, ctx),
-      executeRecall({ query: "gamma" }, ctx),
-    ]);
-
-    expect(r1.success).toBe(true);
-    expect(r2.success).toBe(true);
-    expect(r3.success).toBe(true);
-
-    // Each should have gotten distinct results
-    expect(mockMemoria.recall).toHaveBeenCalledTimes(3);
-  });
-
-  it("concurrent remember and recall should not deadlock or corrupt", async () => {
-    const mockMemoria = createMockMemoria();
-    mockMemoria.remember.mockResolvedValue({ id: "mem-concurrent" });
-    mockMemoria.recall.mockResolvedValue({ memories: [{ id: "m1", content: "data" }] });
-    const ctx = createContext({ memoria: mockMemoria as any });
-
-    // Parallel write + read
-    const [writeResult, readResult] = await Promise.all([
-      executeRemember({ content: "concurrent write" }, ctx),
-      executeRecall({ query: "concurrent read" }, ctx),
-    ]);
-
-    expect(writeResult.success).toBe(true);
-    expect(readResult.success).toBe(true);
-  });
-});