alvin-bot 4.6.0 → 4.8.0

package/test/subagent-stats.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import fs from "fs";
+import os from "os";
+import { resolve } from "path";
+import type { SubAgentInfo, SubAgentResult } from "../src/services/subagents.js";
+
+const TEST_DATA_DIR = resolve(os.tmpdir(), `alvin-bot-stats-${process.pid}-${Date.now()}`);
+
+beforeEach(() => {
+  if (fs.existsSync(TEST_DATA_DIR)) fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+  fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
+  process.env.ALVIN_DATA_DIR = TEST_DATA_DIR;
+  vi.resetModules();
+});
+
+function makeInfo(overrides: Partial<SubAgentInfo> = {}): SubAgentInfo {
+  return {
+    id: "x",
+    name: "test",
+    status: "completed",
+    startedAt: Date.now() - 1000,
+    source: "user",
+    depth: 0,
+    ...overrides,
+  };
+}
+
+function makeResult(overrides: Partial<SubAgentResult> = {}): SubAgentResult {
+  return {
+    id: "x",
+    name: "test",
+    status: "completed",
+    output: "ok",
+    tokensUsed: { input: 100, output: 50 },
+    duration: 1000,
+    ...overrides,
+  };
+}
+
+describe("subagent-stats (H3)", () => {
+  it("getSubAgentStats returns zeros on a fresh install", async () => {
+    const mod = await import("../src/services/subagent-stats.js");
+    const stats = mod.getSubAgentStats();
+    expect(stats.total.runs).toBe(0);
+    expect(stats.bySource.user.runs).toBe(0);
+    expect(stats.byStatus.completed).toBe(0);
+  });
+
+  it("recordSubAgentRun appends and updates totals", async () => {
+    const mod = await import("../src/services/subagent-stats.js");
+    mod.recordSubAgentRun(makeInfo({ source: "user" }), makeResult({ tokensUsed: { input: 100, output: 50 } }));
+    mod.recordSubAgentRun(makeInfo({ source: "cron" }), makeResult({ tokensUsed: { input: 200, output: 75 } }));
+    mod.recordSubAgentRun(makeInfo({ source: "user" }), makeResult({ tokensUsed: { input: 50, output: 25 } }));
+
+    const stats = mod.getSubAgentStats();
+    expect(stats.total.runs).toBe(3);
+    expect(stats.total.inputTokens).toBe(350);
+    expect(stats.total.outputTokens).toBe(150);
+    expect(stats.bySource.user.runs).toBe(2);
+    expect(stats.bySource.user.inputTokens).toBe(150);
+    expect(stats.bySource.cron.runs).toBe(1);
+    expect(stats.bySource.cron.inputTokens).toBe(200);
+    expect(stats.byStatus.completed).toBe(3);
+  });
+
+  it("persists to disk and round-trips through reload", async () => {
+    let mod = await import("../src/services/subagent-stats.js");
+    mod.recordSubAgentRun(makeInfo({ source: "cron" }), makeResult());
+
+    // Force a reload by resetting modules
+    vi.resetModules();
+    mod = await import("../src/services/subagent-stats.js");
+
+    const stats = mod.getSubAgentStats();
+    expect(stats.total.runs).toBe(1);
+    expect(stats.bySource.cron.runs).toBe(1);
+  });
+
+  it("prunes entries older than 24h", async () => {
+    const mod = await import("../src/services/subagent-stats.js");
+    // Seed the file with an entry from 25 hours ago
+    const ancient = [
+      {
+        completedAt: Date.now() - 25 * 60 * 60 * 1000,
+        name: "ancient",
+        source: "user",
+        status: "completed",
+        durationMs: 100,
+        inputTokens: 999,
+        outputTokens: 999,
+      },
+    ];
+    fs.writeFileSync(
+      resolve(TEST_DATA_DIR, "subagent-stats.json"),
+      JSON.stringify(ancient),
+    );
+    mod.__resetStatsCacheForTest();
+
+    // Fresh read should exclude the ancient entry
+    const stats = mod.getSubAgentStats();
+    expect(stats.total.runs).toBe(0);
+    expect(stats.total.inputTokens).toBe(0);
+  });
+
+  it("tracks byStatus separately for cancelled/error/timeout", async () => {
+    const mod = await import("../src/services/subagent-stats.js");
+    mod.recordSubAgentRun(makeInfo(), makeResult({ status: "completed" }));
+    mod.recordSubAgentRun(makeInfo(), makeResult({ status: "cancelled" }));
+    mod.recordSubAgentRun(makeInfo(), makeResult({ status: "error" }));
+    mod.recordSubAgentRun(makeInfo(), makeResult({ status: "timeout" }));
+    mod.recordSubAgentRun(makeInfo(), makeResult({ status: "completed" }));
+
+    const stats = mod.getSubAgentStats();
+    expect(stats.byStatus.completed).toBe(2);
+    expect(stats.byStatus.cancelled).toBe(1);
+    expect(stats.byStatus.error).toBe(1);
+    expect(stats.byStatus.timeout).toBe(1);
+  });
+});

package/test/subagents-config.test.ts

@@ -96,7 +96,13 @@ describe("sub-agents visibility config (A4)", () => {
 
   it("rejects invalid visibility values", async () => {
     const mod = await import("../src/services/subagents.js");
-    expect(() => mod.setVisibility("live" as "auto")).toThrow(/invalid/i);
+    expect(() => mod.setVisibility("bogus" as "auto")).toThrow(/invalid/i);
+  });
+
+  it("accepts 'live' as a valid visibility mode (A4 Stufe 2)", async () => {
+    const mod = await import("../src/services/subagents.js");
+    mod.setVisibility("live");
+    expect(mod.getVisibility()).toBe("live");
   });
 
   it("setVisibility('auto') round-trips through disk", async () => {

package/test/subagents-priority-reject.test.ts

@@ -23,10 +23,13 @@ vi.mock("../src/engine.js", () => ({
   }),
 }));
 
-describe("priority-aware reject (D4)", () => {
+describe("priority-aware reject (D4) — queue disabled", () => {
+  // With queueCap=0 the bounded queue is disabled, so hitting the max
+  // parallel limit triggers immediate rejection — the D4 messages.
   it("user-spawn message points out cron/implicit jobs hold the slots", async () => {
     const mod = await import("../src/services/subagents.js");
     mod.setMaxParallelAgents(2);
+    mod.setQueueCap(0);
 
     await mod.spawnSubAgent({ name: "bg-1", prompt: "x", source: "cron" });
     await mod.spawnSubAgent({ name: "bg-2", prompt: "y", source: "implicit" });
@@ -39,6 +42,7 @@ describe("priority-aware reject (D4)", () => {
   it("user-spawn message blames user agents when they hold all slots", async () => {
     const mod = await import("../src/services/subagents.js");
     mod.setMaxParallelAgents(2);
+    mod.setQueueCap(0);
 
     await mod.spawnSubAgent({ name: "u1", prompt: "x", source: "user" });
     await mod.spawnSubAgent({ name: "u2", prompt: "y", source: "user" });
@@ -51,6 +55,7 @@ describe("priority-aware reject (D4)", () => {
   it("cron and implicit rejects use the generic message", async () => {
     const mod = await import("../src/services/subagents.js");
     mod.setMaxParallelAgents(1);
+    mod.setQueueCap(0);
 
     await mod.spawnSubAgent({ name: "first", prompt: "x", source: "user" });
     await expect(
@@ -58,3 +63,26 @@ describe("priority-aware reject (D4)", () => {
     ).rejects.toThrow(/limit reached/i);
   });
 });
+
+describe("priority-aware reject (D4) — queue enabled", () => {
+  // With a queue, reject only fires when BOTH the running pool and the
+  // queue are full. Queue-enabled rejections still carry the priority-
+  // aware messages because the code path is shared.
+  it("user-spawn rejects with cron-in-queue message when pool + queue are full", async () => {
+    const mod = await import("../src/services/subagents.js");
+    mod.setMaxParallelAgents(2);
+    mod.setQueueCap(2);
+
+    // Fill the running pool with cron agents
+    await mod.spawnSubAgent({ name: "bg-1", prompt: "x", source: "cron" });
+    await mod.spawnSubAgent({ name: "bg-2", prompt: "y", source: "implicit" });
+    // Fill the queue with 2 more
+    await mod.spawnSubAgent({ name: "q-1", prompt: "z", source: "cron" });
+    await mod.spawnSubAgent({ name: "q-2", prompt: "z", source: "cron" });
+
+    // Now a user spawn has nowhere to go → reject
+    await expect(
+      mod.spawnSubAgent({ name: "user-new", prompt: "w", source: "user" }),
+    ).rejects.toThrow(/Queue voll|Hintergrund/i);
+  });
+});

package/test/subagents-queue.test.ts

@@ -0,0 +1,127 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import fs from "fs";
+import os from "os";
+import { resolve } from "path";
+
+/**
+ * Tests for the D3 bounded priority queue.
+ */
+
+const TEST_DATA_DIR = resolve(os.tmpdir(), `alvin-bot-queue-${process.pid}-${Date.now()}`);
+
+beforeEach(() => {
+  if (fs.existsSync(TEST_DATA_DIR)) fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+  fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
+  process.env.ALVIN_DATA_DIR = TEST_DATA_DIR;
+  delete process.env.MAX_SUBAGENTS;
+  vi.resetModules();
+});
+
+// Slow generator so the first 2 agents stay "running" while we test
+// queueing of subsequent spawns.
+vi.mock("../src/engine.js", () => ({
+  getRegistry: () => ({
+    queryWithFallback: async function* () {
+      await new Promise((r) => setTimeout(r, 1000));
+      yield { type: "done", text: "ok", inputTokens: 0, outputTokens: 0 };
+    },
+  }),
+}));
+
+describe("sub-agents bounded queue (D3)", () => {
+  it("getQueueCap defaults to 20", async () => {
+    const mod = await import("../src/services/subagents.js");
+    expect(mod.getQueueCap()).toBe(20);
+  });
+
+  it("setQueueCap persists to disk and round-trips through reload", async () => {
+    const mod = await import("../src/services/subagents.js");
+    mod.setQueueCap(5);
+    expect(mod.getQueueCap()).toBe(5);
+
+    const configPath = resolve(TEST_DATA_DIR, "sub-agents.json");
+    const persisted = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    expect(persisted.queueCap).toBe(5);
+  });
+
+  it("clamps setQueueCap to [0, ABSOLUTE_MAX_QUEUE]", async () => {
+    const mod = await import("../src/services/subagents.js");
+    expect(mod.setQueueCap(-5)).toBe(0);
+    expect(mod.setQueueCap(500)).toBe(200); // ABSOLUTE_MAX_QUEUE
+    expect(mod.setQueueCap(7.9)).toBe(7);
+  });
+
+  it("third spawn at full pool lands in the queue as status=queued", async () => {
+    const mod = await import("../src/services/subagents.js");
+    mod.setMaxParallelAgents(2);
+    mod.setQueueCap(20);
+
+    await mod.spawnSubAgent({ name: "a", prompt: "x", source: "user" });
+    await mod.spawnSubAgent({ name: "b", prompt: "y", source: "user" });
+    const id = await mod.spawnSubAgent({ name: "c", prompt: "z", source: "user" });
+
+    const info = mod.listSubAgents().find((a) => a.id === id);
+    expect(info?.status).toBe("queued");
+    expect(info?.queuePosition).toBe(1);
+  });
+
+  it("queue drains automatically when a running agent finishes", async () => {
+    const mod = await import("../src/services/subagents.js");
+    mod.setMaxParallelAgents(2);
+    mod.setQueueCap(20);
+
+    await mod.spawnSubAgent({ name: "a", prompt: "x", source: "user" });
+    await mod.spawnSubAgent({ name: "b", prompt: "y", source: "user" });
+    const cId = await mod.spawnSubAgent({ name: "c", prompt: "z", source: "user" });
+
+    // c is queued
+    expect(mod.listSubAgents().find((a) => a.id === cId)?.status).toBe("queued");
+
+    // Wait for the first two to finish (1s each) + drain cycle
+    await new Promise((r) => setTimeout(r, 1400));
+
+    // c should now be running or completed
+    const cInfo = mod.listSubAgents().find((a) => a.id === cId);
+    expect(["running", "completed"]).toContain(cInfo?.status);
+  });
+
+  it("priority order: user spawns drain before cron at the same moment", async () => {
+    const mod = await import("../src/services/subagents.js");
+    mod.setMaxParallelAgents(1);
+    mod.setQueueCap(20);
+
+    // One running blocker
+    await mod.spawnSubAgent({ name: "blocker", prompt: "x", source: "user" });
+    // Queue order: cron first, then user — BUT the drain should pick user first
+    const cronId = await mod.spawnSubAgent({ name: "cron-q", prompt: "y", source: "cron" });
+    const userId = await mod.spawnSubAgent({ name: "user-q", prompt: "z", source: "user" });
+
+    // Wait for blocker to finish and drain
+    await new Promise((r) => setTimeout(r, 1200));
+
+    const cronInfo = mod.listSubAgents().find((a) => a.id === cronId);
+    const userInfo = mod.listSubAgents().find((a) => a.id === userId);
+
+    // user agent should be running or done; cron should still be queued
+    // (because user has higher priority when draining)
+    expect(["running", "completed"]).toContain(userInfo?.status);
+    expect(cronInfo?.status).toBe("queued");
+  });
+
+  it("cancelSubAgent removes a queued entry from the queue", async () => {
+    const mod = await import("../src/services/subagents.js");
+    mod.setMaxParallelAgents(1);
+    mod.setQueueCap(20);
+
+    await mod.spawnSubAgent({ name: "blocker", prompt: "x", source: "user" });
+    const qId = await mod.spawnSubAgent({ name: "victim", prompt: "y", source: "user" });
+
+    expect(mod.listSubAgents().find((a) => a.id === qId)?.status).toBe("queued");
+
+    const ok = mod.cancelSubAgent(qId);
+    expect(ok).toBe(true);
+
+    const info = mod.listSubAgents().find((a) => a.id === qId);
+    expect(info?.status).toBe("cancelled");
+  });
+});