alvin-bot 4.5.1 → 4.7.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-commands.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import fs from "fs";
+import os from "os";
+import { resolve } from "path";
+
+const TEST_DATA_DIR = resolve(os.tmpdir(), `alvin-bot-cmds-${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();
+});
+
+vi.mock("../src/engine.js", () => ({
+  getRegistry: () => ({
+    queryWithFallback: async function* () {
+      await new Promise((r) => setTimeout(r, 500));
+      yield { type: "done", text: "ok", inputTokens: 0, outputTokens: 0 };
+    },
+  }),
+}));
+
+describe("cancelSubAgentByName / getSubAgentResultByName (B2 helpers)", () => {
+  it("cancels an agent by its exact name", async () => {
+    const mod = await import("../src/services/subagents.js");
+    const id = await mod.spawnSubAgent({ name: "foo", prompt: "a" });
+    const ok = mod.cancelSubAgentByName("foo");
+    expect(ok).toBe(true);
+
+    const info = mod.listSubAgents().find((a) => a.id === id);
+    expect(info?.status).toBe("cancelled");
+  });
+
+  it("cancels the base-name when unambiguous", async () => {
+    const mod = await import("../src/services/subagents.js");
+    await mod.spawnSubAgent({ name: "bar", prompt: "a" });
+    expect(mod.cancelSubAgentByName("bar")).toBe(true);
+  });
+
+  it("returns false for unknown name", async () => {
+    const mod = await import("../src/services/subagents.js");
+    expect(mod.cancelSubAgentByName("ghost")).toBe(false);
+  });
+
+  it("cancels the #N variant when addressed directly", async () => {
+    const mod = await import("../src/services/subagents.js");
+    await mod.spawnSubAgent({ name: "baz", prompt: "a" });
+    await mod.spawnSubAgent({ name: "baz", prompt: "b" });
+    const ok = mod.cancelSubAgentByName("baz#2");
+    expect(ok).toBe(true);
+
+    const agents = mod.listSubAgents();
+    const canceledNames = agents.filter((a) => a.status === "cancelled").map((a) => a.name);
+    expect(canceledNames).toEqual(["baz#2"]);
+  });
+
+  it("getSubAgentResultByName returns null when still running", async () => {
+    const mod = await import("../src/services/subagents.js");
+    await mod.spawnSubAgent({ name: "running", prompt: "a" });
+    expect(mod.getSubAgentResultByName("running")).toBeNull();
+  });
+});

package/test/subagents-config.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import fs from "fs";
+import { resolve } from "path";
+import os from "os";
+
+/**
+ * Tests for the file-backed sub-agents config.
+ *
+ * We isolate via ALVIN_DATA_DIR pointing at a temp directory, so the test
+ * never touches the real ~/.alvin-bot/sub-agents.json. vi.resetModules()
+ * clears Vitest's module cache between tests so each import() gets a
+ * fresh module with a fresh configCache.
+ */
+
+const TEST_DATA_DIR = resolve(os.tmpdir(), `alvin-bot-test-${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(); // force re-import of subagents.ts next time
+});
+
+afterEach(() => {
+  if (fs.existsSync(TEST_DATA_DIR)) {
+    fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+  }
+});
+
+describe("sub-agents config", () => {
+  it("returns 0 as the configured value on a fresh install", async () => {
+    const mod = await import("../src/services/subagents.js");
+    expect(mod.getConfiguredMaxParallel()).toBe(0);
+  });
+
+  it("resolves 0 to min(cpuCount, 16) in getMaxParallelAgents", async () => {
+    const mod = await import("../src/services/subagents.js");
+    const effective = mod.getMaxParallelAgents();
+    const cpuCount = os.cpus().length;
+    expect(effective).toBe(Math.min(cpuCount, 16));
+  });
+
+  it("setMaxParallelAgents persists the value to disk", async () => {
+    const mod = await import("../src/services/subagents.js");
+    mod.setMaxParallelAgents(5);
+    expect(mod.getConfiguredMaxParallel()).toBe(5);
+    expect(mod.getMaxParallelAgents()).toBe(5);
+
+    // Verify file on disk
+    const configPath = resolve(TEST_DATA_DIR, "sub-agents.json");
+    expect(fs.existsSync(configPath)).toBe(true);
+    const persisted = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    expect(persisted.maxParallel).toBe(5);
+  });
+
+  it("clamps values above ABSOLUTE_MAX (16) down to 16", async () => {
+    const mod = await import("../src/services/subagents.js");
+    const effective = mod.setMaxParallelAgents(500);
+    expect(effective).toBe(16);
+    expect(mod.getConfiguredMaxParallel()).toBe(16);
+  });
+
+  it("clamps negative values to 0 (which then resolves to auto)", async () => {
+    const mod = await import("../src/services/subagents.js");
+    const effective = mod.setMaxParallelAgents(-5);
+    expect(mod.getConfiguredMaxParallel()).toBe(0);
+    expect(effective).toBe(Math.min(os.cpus().length, 16));
+  });
+
+  it("floors fractional values", async () => {
+    const mod = await import("../src/services/subagents.js");
+    mod.setMaxParallelAgents(7.8);
+    expect(mod.getConfiguredMaxParallel()).toBe(7);
+  });
+});
+
+describe("sub-agents visibility config (A4)", () => {
+  it("defaults visibility to 'auto' on a fresh install", async () => {
+    const mod = await import("../src/services/subagents.js");
+    expect(mod.getVisibility()).toBe("auto");
+  });
+
+  it("setVisibility persists the value to disk", async () => {
+    const mod = await import("../src/services/subagents.js");
+    mod.setVisibility("banner");
+    expect(mod.getVisibility()).toBe("banner");
+
+    const configPath = resolve(TEST_DATA_DIR, "sub-agents.json");
+    expect(fs.existsSync(configPath)).toBe(true);
+    const persisted = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    expect(persisted.visibility).toBe("banner");
+  });
+
+  it("rejects invalid visibility values", async () => {
+    const mod = await import("../src/services/subagents.js");
+    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 () => {
+    const mod = await import("../src/services/subagents.js");
+    mod.setVisibility("banner");
+    mod.setVisibility("auto");
+    expect(mod.getVisibility()).toBe("auto");
+  });
+});

package/test/subagents-depth.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import fs from "fs";
+import os from "os";
+import { resolve } from "path";
+
+const TEST_DATA_DIR = resolve(os.tmpdir(), `alvin-bot-depth-${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();
+});
+
+// Stub the engine so spawnSubAgent doesn't actually invoke any LLM.
+vi.mock("../src/engine.js", () => ({
+  getRegistry: () => ({
+    queryWithFallback: async function* () {
+      yield { type: "text", text: "ok" };
+      yield { type: "done", text: "ok", inputTokens: 1, outputTokens: 1 };
+    },
+  }),
+}));
+
+describe("sub-agents depth-cap (F2)", () => {
+  it("accepts depth 0 (root)", async () => {
+    const mod = await import("../src/services/subagents.js");
+    const id = await mod.spawnSubAgent({ name: "d0", prompt: "hi", depth: 0 });
+    expect(id).toMatch(/^[0-9a-f-]{36}$/);
+  });
+
+  it("accepts depth 1", async () => {
+    const mod = await import("../src/services/subagents.js");
+    const id = await mod.spawnSubAgent({ name: "d1", prompt: "hi", depth: 1 });
+    expect(id).toMatch(/^[0-9a-f-]{36}$/);
+  });
+
+  it("accepts depth 2 (the cap)", async () => {
+    const mod = await import("../src/services/subagents.js");
+    const id = await mod.spawnSubAgent({ name: "d2", prompt: "hi", depth: 2 });
+    expect(id).toMatch(/^[0-9a-f-]{36}$/);
+  });
+
+  it("rejects depth 3 with a clear error", async () => {
+    const mod = await import("../src/services/subagents.js");
+    await expect(
+      mod.spawnSubAgent({ name: "d3", prompt: "hi", depth: 3 }),
+    ).rejects.toThrow(/depth limit/i);
+  });
+
+  it("defaults depth to 0 when omitted", async () => {
+    const mod = await import("../src/services/subagents.js");
+    const id = await mod.spawnSubAgent({ name: "nodepth", prompt: "hi" });
+    const info = mod.listSubAgents().find((a) => a.id === id);
+    expect(info?.depth).toBe(0);
+  });
+});

package/test/subagents-inheritance.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import fs from "fs";
+import os from "os";
+import { resolve } from "path";
+
+const TEST_DATA_DIR = resolve(os.tmpdir(), `alvin-bot-inherit-${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();
+});
+
+// Capture what queryWithFallback is called with, so we can inspect workingDir.
+let capturedOptions: Record<string, unknown> | null = null;
+
+vi.mock("../src/engine.js", () => ({
+  getRegistry: () => ({
+    queryWithFallback: async function* (options: Record<string, unknown>) {
+      capturedOptions = options;
+      yield { type: "text", text: "ok" };
+      yield { type: "done", text: "ok", inputTokens: 0, outputTokens: 0 };
+    },
+  }),
+}));
+
+// Small sleep helper — spawnSubAgent is fire-and-forget, we wait for the
+// background task to reach queryWithFallback.
+const tick = () => new Promise((r) => setTimeout(r, 50));
+
+describe("sub-agents inheritance (C3)", () => {
+  beforeEach(() => {
+    capturedOptions = null;
+  });
+
+  it("passes the provided workingDir to queryWithFallback", async () => {
+    const mod = await import("../src/services/subagents.js");
+    await mod.spawnSubAgent({
+      name: "cwd-test",
+      prompt: "hi",
+      workingDir: "/tmp/inherited-project",
+    });
+    await tick();
+    expect(capturedOptions?.workingDir).toBe("/tmp/inherited-project");
+  });
+
+  it("falls back to os.homedir() when workingDir is not provided", async () => {
+    const mod = await import("../src/services/subagents.js");
+    await mod.spawnSubAgent({ name: "no-cwd", prompt: "hi" });
+    await tick();
+    expect(capturedOptions?.workingDir).toBe(os.homedir());
+  });
+
+  it("respects inheritCwd=false by defaulting to homedir regardless of workingDir", async () => {
+    const mod = await import("../src/services/subagents.js");
+    await mod.spawnSubAgent({
+      name: "no-inherit",
+      prompt: "hi",
+      workingDir: "/tmp/should-be-ignored",
+      inheritCwd: false,
+    });
+    await tick();
+    expect(capturedOptions?.workingDir).toBe(os.homedir());
+  });
+});

package/test/subagents-name-resolver.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import fs from "fs";
+import os from "os";
+import { resolve } from "path";
+
+const TEST_DATA_DIR = resolve(os.tmpdir(), `alvin-bot-name-${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();
+});
+
+// Long-running engine stub: holds for 500ms so entries stay "running"
+// while we interrogate the resolver.
+vi.mock("../src/engine.js", () => ({
+  getRegistry: () => ({
+    queryWithFallback: async function* () {
+      await new Promise((r) => setTimeout(r, 500));
+      yield { type: "done", text: "ok", inputTokens: 0, outputTokens: 0 };
+    },
+  }),
+}));
+
+describe("sub-agents name resolver (B2)", () => {
+  it("spawning a second agent with the same name adds #2 suffix", async () => {
+    const mod = await import("../src/services/subagents.js");
+    await mod.spawnSubAgent({ name: "review", prompt: "a" });
+    await mod.spawnSubAgent({ name: "review", prompt: "b" });
+
+    const agents = mod.listSubAgents();
+    const names = agents.map((a) => a.name).sort();
+    expect(names).toEqual(["review", "review#2"]);
+  });
+
+  it("spawning a third adds #3 when #2 is also running", async () => {
+    const mod = await import("../src/services/subagents.js");
+    await mod.spawnSubAgent({ name: "review", prompt: "a" });
+    await mod.spawnSubAgent({ name: "review", prompt: "b" });
+    await mod.spawnSubAgent({ name: "review", prompt: "c" });
+
+    const names = mod.listSubAgents().map((a) => a.name).sort();
+    expect(names).toEqual(["review", "review#2", "review#3"]);
+  });
+
+  it("different base names do not interfere", async () => {
+    const mod = await import("../src/services/subagents.js");
+    await mod.spawnSubAgent({ name: "review", prompt: "a" });
+    await mod.spawnSubAgent({ name: "scan", prompt: "b" });
+
+    const names = mod.listSubAgents().map((a) => a.name).sort();
+    expect(names).toEqual(["review", "scan"]);
+  });
+
+  it("findSubAgentByName returns exact match when unambiguous", async () => {
+    const mod = await import("../src/services/subagents.js");
+    await mod.spawnSubAgent({ name: "review", prompt: "a" });
+    const match = mod.findSubAgentByName("review");
+    expect(match).not.toBeNull();
+    if (match && !("ambiguous" in match)) {
+      expect(match.name).toBe("review");
+    }
+  });
+
+  it("findSubAgentByName returns null for unknown name", async () => {
+    const mod = await import("../src/services/subagents.js");
+    await mod.spawnSubAgent({ name: "review", prompt: "a" });
+    expect(mod.findSubAgentByName("ghost")).toBeNull();
+  });
+
+  it("findSubAgentByName returns the #N variant when addressed directly", async () => {
+    const mod = await import("../src/services/subagents.js");
+    await mod.spawnSubAgent({ name: "review", prompt: "a" });
+    await mod.spawnSubAgent({ name: "review", prompt: "b" });
+    const match = mod.findSubAgentByName("review#2");
+    expect(match).not.toBeNull();
+    if (match && !("ambiguous" in match)) {
+      expect(match.name).toBe("review#2");
+    }
+  });
+
+  it("findSubAgentByName with ambiguousAsList still honours exact #N match", async () => {
+    // Regression test: the previous implementation checked base-name
+    // siblings BEFORE the exact match when ambiguousAsList was set, so
+    // queries like findSubAgentByName("review#2", { ambiguousAsList: true })
+    // incorrectly returned an ambiguity marker instead of the specific
+    // #2 entry. Explicit disambiguation via #N must always win.
+    const mod = await import("../src/services/subagents.js");
+    await mod.spawnSubAgent({ name: "review", prompt: "a" });
+    await mod.spawnSubAgent({ name: "review", prompt: "b" });
+
+    const match = mod.findSubAgentByName("review#2", { ambiguousAsList: true });
+    expect(match).not.toBeNull();
+    if (match && "ambiguous" in match) {
+      throw new Error(`Expected exact match for 'review#2', got ambiguous marker: ${JSON.stringify(match)}`);
+    }
+    expect(match?.name).toBe("review#2");
+  });
+
+  it("findSubAgentByName returns an ambiguity marker when a basename has >1 variant", async () => {
+    const mod = await import("../src/services/subagents.js");
+    await mod.spawnSubAgent({ name: "review", prompt: "a" });
+    await mod.spawnSubAgent({ name: "review", prompt: "b" });
+    // Query the bare basename that also exists as exact → exact match wins.
+    // So we use a non-matching basename form to trigger ambiguity: the
+    // basename "review" matches exactly, so we need to query something
+    // that is neither exact nor unique — we use the exact query but with
+    // an ambiguousAsList opt-in, which should now return the marker
+    // because there are two siblings under the "review" base name.
+    const result = mod.findSubAgentByName("review", { ambiguousAsList: true });
+    // In ambiguous mode, return an object with { ambiguous: true, candidates: [...] }
+    expect(result).toMatchObject({
+      ambiguous: true,
+    });
+    if (result && "ambiguous" in result) {
+      const names = result.candidates.map((c) => c.name).sort();
+      expect(names).toEqual(["review", "review#2"]);
+    }
+  });
+});

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

@@ -0,0 +1,88 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import fs from "fs";
+import os from "os";
+import { resolve } from "path";
+
+const TEST_DATA_DIR = resolve(os.tmpdir(), `alvin-bot-reject-${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;
+  process.env.MAX_SUBAGENTS = "2";
+  vi.resetModules();
+});
+
+// Long-running engine stub — holds agents in 'running' state
+vi.mock("../src/engine.js", () => ({
+  getRegistry: () => ({
+    queryWithFallback: async function* () {
+      await new Promise((r) => setTimeout(r, 5000));
+      yield { type: "done", text: "ok", inputTokens: 0, outputTokens: 0 };
+    },
+  }),
+}));
+
+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" });
+
+    await expect(
+      mod.spawnSubAgent({ name: "user-new", prompt: "z", source: "user" }),
+    ).rejects.toThrow(/cron\/implicit|Hintergrund/i);
+  });
+
+  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" });
+
+    await expect(
+      mod.spawnSubAgent({ name: "u3", prompt: "z", source: "user" }),
+    ).rejects.toThrow(/user-spawns|cancel/i);
+  });
+
+  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(
+      mod.spawnSubAgent({ name: "cron-new", prompt: "y", source: "cron" }),
+    ).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);
+  });
+});