joonecli 0.1.1 → 0.2.0

package/tests/core/stability.test.ts

@@ -1,165 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ContextGuard } from "../../src/core/contextGuard.js";
-import { AutoSave } from "../../src/core/autoSave.js";
-import { ContextState, CacheOptimizedPromptBuilder } from "../../src/core/promptBuilder.js";
-import { HumanMessage, AIMessage, SystemMessage } from "@langchain/core/messages";
-
-// ─── Mocks ──────────────────────────────────────────────────────────────────────
-
-const mockLLM = {
-  invoke: vi.fn(),
-};
-
-// ─── ContextGuard Tests ─────────────────────────────────────────────────────────
-
-describe("ContextGuard", () => {
-  let promptBuilder: CacheOptimizedPromptBuilder;
-
-  beforeEach(() => {
-    promptBuilder = new CacheOptimizedPromptBuilder();
-    vi.clearAllMocks();
-  });
-
-  const createHistory = (numMessages: number) => {
-    return Array.from({ length: numMessages }).map((_, i) => new HumanMessage(`Message ${i}`));
-  };
-
-  const createDummyState = (numMessages: number): ContextState => ({
-    globalSystemInstructions: "System",
-    projectMemory: "Memory",
-    sessionContext: "Context",
-    conversationHistory: createHistory(numMessages),
-  });
-
-  it("does nothing when under the warn threshold", async () => {
-    // 1000 max tokens. A state with 5 short messages is well under 800 tokens.
-    const guard = new ContextGuard(mockLLM as any, 1000, promptBuilder);
-    const state = createDummyState(5);
-
-    const { state: updatedState, metrics } = await guard.ensureCapacity(state, 0.8, 0.95);
-
-    expect(metrics.actionTaken).toBe("none");
-    expect(updatedState.conversationHistory.length).toBe(5);
-  });
-
-  it("triggers LLM compaction when over WARN but under CRITICAL threshold", async () => {
-    // We create a very small maxTokens, so the dummy state blows past 80%
-    const guard = new ContextGuard(mockLLM as any, 100, promptBuilder);
-    
-    // 30 messages will definitely be hundreds of tokens, exceeding 100 * 0.8
-    const state = createDummyState(30);
-    
-    // We mock promptBuilder.compactHistoryWithLLM directly
-    vi.spyOn(promptBuilder, "compactHistoryWithLLM").mockResolvedValue({
-      compactedHistory: createHistory(8),
-      tokensBefore: 400,
-      tokensAfter: 20,
-      evictedCount: 22,
-      llmUsed: true,
-    });
-
-    const { metrics } = await guard.ensureCapacity(state, 0.8, 0.95);
-    
-    // If it exceeds 95 it hits emergency, if it's < 95 it hits compacted.
-    // 30 short messages is actually huge for a 100 token max, so it will hit 95% immediately.
-    // So let's test for what actually happens algebraically:
-    expect(["compacted", "emergency_truncated"]).toContain(metrics.actionTaken);
-  });
-});
-
-// Since vitest mocks affect the whole module, we'll test the logic algebraically without deep module overriding.
-describe("ContextGuard Algebraic Logic", () => {
-  it("compacts via emergency truncation when 95% full and history > 4", async () => {
-    const builder = new CacheOptimizedPromptBuilder();
-    vi.spyOn(builder, "compactHistoryWithLLM").mockResolvedValue({
-      compactedHistory: [new SystemMessage("Compacted")],
-      tokensBefore: 100,
-      tokensAfter: 10,
-      evictedCount: 2,
-      llmUsed: true,
-    });
-
-    const guard = new ContextGuard(mockLLM as any, 100, builder);
-    // Needs > 4 messages to allow emergency truncation
-    const history = Array.from({ length: 10 }).map((_, i) => new HumanMessage("A reasonably sized message structure " + i));
-    const state: ContextState = {
-      globalSystemInstructions: "System instructions taking up exactly enough tokens to push us to 85. ".repeat(7),
-      projectMemory: "",
-      sessionContext: "",
-      conversationHistory: history,
-    };
-
-    const { metrics } = await guard.ensureCapacity(state);
-
-    expect(["compacted", "emergency_truncated"]).toContain(metrics.actionTaken);
-  });
-});
-
-// ─── AutoSave Tests ─────────────────────────────────────────────────────────────
-
-describe("AutoSave", () => {
-  it("only saves when frequency and debounce thresholds are met", async () => {
-    const mockStore = { saveSession: vi.fn().mockResolvedValue(true) };
-    const autoSave = new AutoSave("test_session", mockStore as any, 3, 100);
-
-    const dummyData = { config: { provider: "test", model: "test" }, state: { conversationHistory: [] } as any };
-
-    // Turn 1
-    let saved = await autoSave.tick(dummyData);
-    expect(saved).toBe(false);
-
-    // Turn 2
-    saved = await autoSave.tick(dummyData);
-    expect(saved).toBe(false);
-
-    // Turn 3 (Hits frequency)
-    saved = await autoSave.tick(dummyData);
-    expect(saved).toBe(true);
-    expect(mockStore.saveSession).toHaveBeenCalledTimes(1);
-
-    // Turn 4 (Frequency reset, hasn't hit 3 again)
-    saved = await autoSave.tick(dummyData);
-    expect(saved).toBe(false);
-  });
-
-  it("respects debounce time even if frequency is met", async () => {
-    const mockStore = { saveSession: vi.fn().mockResolvedValue(true) };
-    // Huge debounce, frequency of 1
-    const autoSave = new AutoSave("test_session", mockStore as any, 1, 10000);
-
-    const dummyData = { config: { provider: "test", model: "test" }, state: { conversationHistory: [] } as any };
-
-    // Turn 1 (Hits frequency 1, saves and resets timer)
-    let saved = await autoSave.tick(dummyData);
-    expect(saved).toBe(true);
-    expect(mockStore.saveSession).toHaveBeenCalledTimes(1);
-
-    // Turn 2 (Hits frequency 1 again! But debounce rejects it)
-    saved = await autoSave.tick(dummyData);
-    expect(saved).toBe(false);
-    expect(mockStore.saveSession).toHaveBeenCalledTimes(1); // Still 1
-  });
-
-  it("forceSave bypasses thresholds", async () => {
-    const mockStore = { saveSession: vi.fn().mockResolvedValue(true) };
-    const autoSave = new AutoSave("test_session", mockStore as any, 5, 10000);
-
-    const dummyData = { config: { provider: "test", model: "test" }, state: { conversationHistory: [] } as any };
-
-    await autoSave.forceSave(dummyData);
-    expect(mockStore.saveSession).toHaveBeenCalledTimes(1);
-  });
-
-  it("swallows errors to prevent crashing the agent loop", async () => {
-    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-    const mockStore = { saveSession: vi.fn().mockRejectedValue(new Error("Disk full")) };
-    
-    const autoSave = new AutoSave("test_session", mockStore as any, 1, 0);
-    const dummyData = { config: { provider: "test", model: "test" }, state: { conversationHistory: [] } as any };
-
-    // Should not throw
-    await expect(autoSave.tick(dummyData)).resolves.toBe(true);
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Disk full"));
-    consoleSpy.mockRestore();
-  });
-});

package/tests/core/subAgent.test.ts

@@ -1,238 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { SubAgentManager } from "../../src/core/subAgent.js";
-import { AgentRegistry } from "../../src/agents/agentRegistry.js";
-import { createSpawnAgentTools } from "../../src/tools/spawnAgent.js";
-import { AgentSpec } from "../../src/agents/agentSpec.js";
-import { AIMessage, ToolMessage } from "@langchain/core/messages";
-import { DynamicToolInterface } from "../../src/tools/index.js";
-
-// ─── Mocks ──────────────────────────────────────────────────────────────────────
-
-const mockRegistry = new AgentRegistry();
-const mockSpec: AgentSpec = {
-  name: "test_agent",
-  description: "A test agent",
-  systemPrompt: "You are a test agent.",
-  tools: ["test_tool"],
-  maxTurns: 3,
-};
-mockRegistry.register(mockSpec);
-
-const mockTool: DynamicToolInterface = {
-  name: "test_tool",
-  description: "A test tool",
-  schema: { type: "object", properties: {} },
-  execute: async () => ({ content: "Tool success" }),
-};
-
-const mockTools = [mockTool];
-
-function createMockLLM(responses: any[]) {
-  let callCount = 0;
-  return {
-    bindTools: vi.fn().mockReturnThis(),
-    invoke: vi.fn().mockImplementation(() => {
-      const resp = responses[callCount++] || responses[responses.length - 1];
-      return Promise.resolve(resp);
-    }),
-  };
-}
-
-// ─── SubAgentManager Tests ──────────────────────────────────────────────────────
-
-describe("SubAgentManager", () => {
-  it("rejects unknown agents", async () => {
-    const llm = createMockLLM([new AIMessage("Hello")]);
-    const manager = new SubAgentManager(mockRegistry, mockTools, llm as any);
-
-    const result = await manager.spawn("unknown_agent", "Do something");
-    expect(result.outcome).toBe("failure");
-    expect(result.result).toContain("Unknown agent");
-  });
-
-  it("safely filters out spawn_agent and check_agent from available tools", async () => {
-    // Tests depth-1 safety limit
-    const unsafeTools = [
-      mockTool,
-      { name: "spawn_agent", description: "", schema: {}, execute: async () => ({ content: "" }) },
-      { name: "check_agent", description: "", schema: {}, execute: async () => ({ content: "" }) }
-    ];
-    
-    // We must cast these unsafeTools since they bypass DynamicToolInterface loosely here
-    const manager = new SubAgentManager(mockRegistry, unsafeTools as any, createMockLLM([]) as any);
-    
-    // Access private allTools to verify
-    const allTools = (manager as any).allTools;
-    expect(allTools.length).toBe(1);
-    expect(allTools[0].name).toBe("test_tool");
-  });
-
-  it("handles a successful sync execution without tool calls", async () => {
-    const llm = createMockLLM([new AIMessage("I have completed the task.")]);
-    const manager = new SubAgentManager(mockRegistry, mockTools, llm as any);
-
-    const result = await manager.spawn("test_agent", "Do something");
-    
-    expect(result.outcome).toBe("success");
-    expect(result.result).toBe("I have completed the task.");
-    expect(result.turnsUsed).toBe(1);
-    expect(result.toolCallCount).toBe(0);
-  });
-
-  it("handles tool calls recursively until finished", async () => {
-    const llm = createMockLLM([
-      new AIMessage({
-        content: "I need to use a tool.",
-        tool_calls: [{ id: "call_1", name: "test_tool", args: {} }] 
-      }),
-      new AIMessage("I have finished the task with the tool.")
-    ]);
-    const manager = new SubAgentManager(mockRegistry, mockTools, llm as any);
-
-    const result = await manager.spawn("test_agent", "Do something");
-    
-    expect(result.outcome).toBe("success");
-    expect(result.result).toBe("I have finished the task with the tool.");
-    expect(result.turnsUsed).toBe(2);
-    expect(result.toolCallCount).toBe(1);
-  });
-
-  it("returns partial outcome if maxTurns is exceeded", async () => {
-    // LLM keeps returning tool calls, but agent has maxTurns = 3
-    const llm = createMockLLM([
-      new AIMessage({ content: "Loop 1", tool_calls: [{ id: "c1", name: "test_tool", args: {} }] }),
-      new AIMessage({ content: "Loop 2", tool_calls: [{ id: "c2", name: "test_tool", args: {} }] }),
-      new AIMessage({ content: "Loop 3", tool_calls: [{ id: "c3", name: "test_tool", args: {} }] }),
-      new AIMessage("This should never be reached")
-    ]);
-    const manager = new SubAgentManager(mockRegistry, mockTools, llm as any);
-
-    const result = await manager.spawn("test_agent", "Loop forever");
-    
-    expect(result.outcome).toBe("partial"); // Caught by loop protection
-    expect(result.turnsUsed).toBe(3);
-  });
-
-  it("tracks modified files when write_file is called", async () => {
-    const writeTool: DynamicToolInterface = {
-      name: "write_file",
-      description: "Writes a file",
-      schema: { type: "object", properties: { path: { type: "string" } } },
-      execute: async () => ({ content: "Written" }),
-    };
-    
-    const reg = new AgentRegistry();
-    reg.register({ name: "writer", description: "", systemPrompt: "", tools: ["write_file"] });
-
-    const llm = createMockLLM([
-      new AIMessage({
-        content: "",
-        tool_calls: [{ id: "c1", name: "write_file", args: { path: "/test/file.ts" } }]
-      }),
-      new AIMessage("Done writing.")
-    ]);
-    
-    const manager = new SubAgentManager(reg, [writeTool], llm as any);
-    const result = await manager.spawn("writer", "Write it");
-
-    expect(result.filesModified).toContain("/test/file.ts");
-  });
-
-  describe("Async execution", () => {
-    it("spawns a non-blocking async task and checks its result", async () => {
-      // Delay the LLM so it's realistically async
-      const llm = {
-        bindTools: vi.fn().mockReturnThis(),
-        invoke: vi.fn().mockImplementation(async () => {
-          await new Promise((r) => setTimeout(r, 50));
-          return new AIMessage("Async done");
-        }),
-      };
-      
-      const manager = new SubAgentManager(mockRegistry, mockTools, llm as any);
-
-      // Spawn async
-      const taskId = await manager.spawnAsync("test_agent", "Do async task");
-      expect(taskId).toMatch(/^task_\d+_\d+$/);
-
-      // Check immediately — should be running
-      const initialCheck = await manager.getResult(taskId);
-      expect(typeof initialCheck).toBe("string");
-      expect(initialCheck).toContain("still running");
-
-      // Wait for it to finish
-      await new Promise((r) => setTimeout(r, 100));
-
-      // Check again — should be the result object
-      const finalCheck = await manager.getResult(taskId);
-      expect(typeof finalCheck).toBe("object");
-      expect((finalCheck as any).outcome).toBe("success");
-      expect((finalCheck as any).result).toBe("Async done");
-    });
-
-    it("prevents spawning beyond MAX_CONCURRENT_ASYNC", async () => {
-      // LLM that hangs forever so tasks stay active
-      const llm = {
-        bindTools: vi.fn().mockReturnThis(),
-        invoke: vi.fn().mockImplementation(() => new Promise(() => {})), // never resolves
-      };
-      
-      const manager = new SubAgentManager(mockRegistry, mockTools, llm as any);
-
-      // Spawn 3 (max)
-      await manager.spawnAsync("test_agent", "Task 1");
-      await manager.spawnAsync("test_agent", "Task 2");
-      await manager.spawnAsync("test_agent", "Task 3");
-
-      // 4th should throw an error
-      await expect(manager.spawnAsync("test_agent", "Task 4"))
-        .rejects.toThrow(/Maximum concurrent async agents reached/);
-    });
-  });
-});
-
-// ─── spawn_agent & check_agent tools ────────────────────────────────────────────
-
-describe("spawn_agent and check_agent tools", () => {
-  it("formats the spawn result correctly in sync mode", async () => {
-    const llm = createMockLLM([new AIMessage("Test complete")]);
-    const manager = new SubAgentManager(mockRegistry, mockTools, llm as any);
-    const tools = createSpawnAgentTools(manager, mockRegistry);
-    const spawnAgentTool = tools.find(t => t.name === "spawn_agent")!;
-
-    const result = await spawnAgentTool.execute({ agent: "test_agent", task: "Run test" });
-    
-    expect(result.isError).toBe(false);
-    expect(typeof result.content).toBe("string");
-    expect(result.content).toContain("Sub-Agent Result: test_agent");
-    expect(result.content).toContain("Outcome: success");
-    expect(result.content).toContain("Test complete");
-    expect(result.metadata).toBeDefined();
-    expect((result.metadata as any).agentName).toBe("test_agent");
-  });
-
-  it("handles async mode and pairs with check_agent", async () => {
-    const llm = {
-      bindTools: vi.fn().mockReturnThis(),
-      invoke: vi.fn().mockResolvedValue(new AIMessage("Delayed finish")),
-    };
-    const manager = new SubAgentManager(mockRegistry, mockTools, llm as any);
-    const tools = createSpawnAgentTools(manager, mockRegistry);
-    const spawnTool = tools.find(t => t.name === "spawn_agent")!;
-    const checkTool = tools.find(t => t.name === "check_agent")!;
-
-    // Spawn
-    const spawnRes = await spawnTool.execute({ agent: "test_agent", task: "Test", mode: "async" });
-    expect(spawnRes.content).toContain("task_");
-    const taskId = (spawnRes.metadata as any).taskId;
-
-    // Wait a tick for the microtask to finish (the mock resolves immediately)
-    await new Promise(r => setTimeout(r, 10));
-
-    // Check
-    const checkRes = await checkTool.execute({ taskId });
-    expect(checkRes.isError).toBe(false);
-    expect(checkRes.content).toContain("Outcome: success");
-    expect(checkRes.content).toContain("Delayed finish");
-  });
-});

package/tests/hitl/hitlBridge.test.ts

@@ -1,115 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { HITLBridge } from "../../src/hitl/bridge.js";
-import { PermissionMiddleware } from "../../src/middleware/permission.js";
-
-describe("HITLBridge", () => {
-    beforeEach(() => {
-        HITLBridge.resetInstance();
-    });
-
-    it("resolves askUser when the TUI calls resolveAnswer", async () => {
-        const bridge = HITLBridge.getInstance(1000);
-
-        // Simulate TUI responding to a question
-        bridge.on("question", (q) => {
-            setTimeout(() => bridge.resolveAnswer(q.id, "TypeScript"), 50);
-        });
-
-        const answer = await bridge.askUser("What language?");
-        expect(answer).toBe("TypeScript");
-    });
-
-    it("auto-resolves askUser on timeout with no-response message", async () => {
-        const bridge = HITLBridge.getInstance(100); // 100ms timeout for test speed
-
-        const answer = await bridge.askUser("Are you there?");
-        expect(answer).toContain("No response");
-    });
-
-    it("resolves requestPermission to true on 'y' answer", async () => {
-        const bridge = HITLBridge.getInstance(1000);
-
-        bridge.on("permission", (p) => {
-            setTimeout(() => bridge.resolveAnswer(p.id, "y"), 50);
-        });
-
-        const approved = await bridge.requestPermission("bash", { command: "rm -rf /" });
-        expect(approved).toBe(true);
-    });
-
-    it("resolves requestPermission to false on 'n' answer", async () => {
-        const bridge = HITLBridge.getInstance(1000);
-
-        bridge.on("permission", (p) => {
-            setTimeout(() => bridge.resolveAnswer(p.id, "n"), 50);
-        });
-
-        const approved = await bridge.requestPermission("bash", { command: "ls" });
-        expect(approved).toBe(false);
-    });
-
-    it("auto-denies requestPermission on timeout", async () => {
-        const bridge = HITLBridge.getInstance(100);
-
-        const approved = await bridge.requestPermission("bash", { command: "ls" });
-        expect(approved).toBe(false);
-    });
-});
-
-describe("PermissionMiddleware", () => {
-    it("passes through all tools in 'auto' mode", async () => {
-        const mw = new PermissionMiddleware("auto");
-        const ctx = { toolName: "bash", args: { command: "ls" }, callId: "1" };
-
-        const result = await mw.before!(ctx);
-        expect(result).toEqual(ctx); // Unchanged
-    });
-
-    it("allows safe tools in 'ask_dangerous' mode without asking", async () => {
-        const mw = new PermissionMiddleware("ask_dangerous");
-        const ctx = { toolName: "read_file", args: { path: "/foo" }, callId: "2" };
-
-        const result = await mw.before!(ctx);
-        expect(result).toEqual(ctx);
-    });
-
-    it("blocks dangerous tools in 'ask_dangerous' mode when denied", async () => {
-        HITLBridge.resetInstance();
-        const bridge = HITLBridge.getInstance(100); // Auto-deny on timeout
-
-        const mw = new PermissionMiddleware("ask_dangerous");
-        const ctx = { toolName: "bash", args: { command: "rm -rf /" }, callId: "3" };
-
-        const result = await mw.before!(ctx);
-        // Should return short-circuit string (denial)
-        expect(typeof result).toBe("string");
-        expect(result as string).toContain("Permission denied");
-    });
-
-    it("allows dangerous tools in 'ask_dangerous' mode when approved", async () => {
-        HITLBridge.resetInstance();
-        const bridge = HITLBridge.getInstance(5000);
-
-        bridge.on("permission", (p) => {
-            setTimeout(() => bridge.resolveAnswer(p.id, "yes"), 50);
-        });
-
-        const mw = new PermissionMiddleware("ask_dangerous");
-        const ctx = { toolName: "bash", args: { command: "ls" }, callId: "4" };
-
-        const result = await mw.before!(ctx);
-        expect(result).toEqual(ctx); // Approved, return context
-    });
-
-    it("blocks non-safe tools in 'ask_all' mode when denied", async () => {
-        HITLBridge.resetInstance();
-        const bridge = HITLBridge.getInstance(100);
-
-        const mw = new PermissionMiddleware("ask_all");
-        const ctx = { toolName: "run_tests", args: {}, callId: "5" };
-
-        const result = await mw.before!(ctx);
-        expect(typeof result).toBe("string");
-        expect(result as string).toContain("Permission denied");
-    });
-});

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "outDir": "./dist",
-    "jsx": "react-jsx",
-    "declaration": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"]
-}

package/vitest.config.ts

@@ -1,10 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    env: {
-      ANTHROPIC_API_KEY: "test-key-for-vitest",
-      OPENAI_API_KEY: "test-key-for-vitest",
-    },
-  },
-});

package/vitest.out

@@ -1,48 +0,0 @@
-
- RUN  v4.0.18 C:/Users/Lenovo/Desktop/New folder/joone
-
- ❯ tests/core/stability.test.ts (7 tests | 2 failed) 84ms
-     × does nothing when under the warn threshold 26ms
-     ✓ triggers LLM compaction when over WARN but under CRITICAL threshold 2ms
-     × compacts via promptBuilder when 80-95% full 8ms
-     ✓ only saves when frequency and debounce thresholds are met 3ms
-     ✓ respects debounce time even if frequency is met 1ms
-     ✓ forceSave bypasses thresholds 1ms
-     ✓ swallows errors to prevent crashing the agent loop 37ms
-
-⎯⎯⎯⎯⎯⎯⎯ Failed Tests 2 ⎯⎯⎯⎯⎯⎯⎯
-
- FAIL  tests/core/stability.test.ts > ContextGuard > does nothing when under the warn threshold
-AssertionError: expected 'compacted' to be 'none' // Object.is equality
-
-Expected: "none"
-Received: "compacted"
-
- ❯ tests/core/stability.test.ts:41:33
-     39|     const { state: updatedState, metrics } = await guard.ensureCapacit…
-     40| 
-     41|     expect(metrics.actionTaken).toBe("none");
-       |                                 ^
-     42|     expect(updatedState.conversationHistory.length).toBe(5);
-     43|   });
-
-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/2]⎯
-
- FAIL  tests/core/stability.test.ts > ContextGuard Algebraic Logic > compacts via promptBuilder when 80-95% full
-AssertionError: expected [ 'compacted', 'emergency_truncated' ] to include 'none'
- ❯ tests/core/stability.test.ts:95:50
-     93| 
-     94|     // It should hit compactness or emergency
-     95|     expect(["compacted", "emergency_truncated"]).toContain(metrics.act…
-       |                                                  ^
-     96|   });
-     97| });
-
-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[2/2]⎯
-
-
- Test Files  1 failed (1)
-      Tests  2 failed | 5 passed (7)
-   Start at  16:46:44
-   Duration  2.69s (transform 488ms, setup 0ms, import 2.01s, tests 84ms, environment 1ms)
-