alvin-bot 4.6.0 → 4.7.0

package/test/subagent-delivery.test.ts

@@ -167,3 +167,107 @@ describe("subagent-delivery (I3)", () => {
     expect(sentMessages).toHaveLength(0);
   });
 });
+
+describe("subagent-delivery LiveStream (A4)", () => {
+  const edits: Array<{ chatId: number; messageId: number; text: string }> = [];
+  let messageCounter = 100;
+
+  beforeEach(() => {
+    edits.length = 0;
+    messageCounter = 100;
+  });
+
+  async function wireLiveApi() {
+    const mod = await import("../src/services/subagent-delivery.js");
+    mod.__setBotApiForTest({
+      sendMessage: async (chatId: number, text: string) => {
+        sentMessages.push({ chatId, text });
+        return { message_id: messageCounter++ };
+      },
+      sendDocument: async (chatId: number) => {
+        sentDocuments.push({ chatId });
+        return {};
+      },
+      editMessageText: async (chatId: number, messageId: number, text: string) => {
+        edits.push({ chatId, messageId, text });
+        return {};
+      },
+    });
+    return mod;
+  }
+
+  it("start posts an initial 'thinking…' message and records messageId", async () => {
+    const mod = await wireLiveApi();
+    const stream = mod.createLiveStream(555, "code-review");
+    expect(stream).not.toBeNull();
+    await stream!.start();
+
+    expect(sentMessages).toHaveLength(1);
+    expect(sentMessages[0].chatId).toBe(555);
+    expect(sentMessages[0].text).toContain("thinking");
+    expect(stream!.failed).toBe(false);
+  });
+
+  it("update coalesces multiple rapid calls into a single throttled edit", async () => {
+    const mod = await wireLiveApi();
+    const stream = mod.createLiveStream(1, "fast");
+    await stream!.start();
+
+    stream!.update("hello");
+    stream!.update("hello world");
+    stream!.update("hello world and more");
+
+    // Wait for the throttle window to elapse
+    await new Promise((r) => setTimeout(r, 900));
+
+    // Should have produced exactly one edit with the LAST text
+    expect(edits.length).toBe(1);
+    expect(edits[0].text).toContain("hello world and more");
+  });
+
+  it("finalize posts a banner as a new message", async () => {
+    const mod = await wireLiveApi();
+    const stream = mod.createLiveStream(42, "done-agent");
+    await stream!.start();
+    stream!.update("final text");
+    await new Promise((r) => setTimeout(r, 900)); // let flush run
+
+    await stream!.finalize(
+      {
+        id: "x",
+        name: "done-agent",
+        status: "completed",
+        startedAt: Date.now() - 5000,
+        source: "user",
+        depth: 0,
+        parentChatId: 42,
+      },
+      {
+        id: "x",
+        name: "done-agent",
+        status: "completed",
+        output: "final text",
+        tokensUsed: { input: 100, output: 50 },
+        duration: 5000,
+      },
+    );
+
+    // Two sends total: initial "thinking…" + final banner
+    expect(sentMessages.length).toBe(2);
+    const banner = sentMessages[sentMessages.length - 1].text;
+    expect(banner).toContain("done-agent");
+    expect(banner).toContain("completed");
+  });
+
+  it("createLiveStream returns null when bot api lacks editMessageText", async () => {
+    const mod = await import("../src/services/subagent-delivery.js");
+    // Set an api that intentionally has no editMessageText
+    mod.__setBotApiForTest({
+      sendMessage: async () => ({ message_id: 1 }),
+      sendDocument: async () => ({}),
+      // no editMessageText
+    });
+    const stream = mod.createLiveStream(1, "no-edit");
+    expect(stream).toBeNull();
+  });
+});

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");
+  });
+});