stagent 0.9.6 → 0.11.0

package/src/hooks/use-saved-searches.ts

@@ -0,0 +1,142 @@
+"use client";
+
+/**
+ * `useSavedSearches` — client-side store for saved filter combinations
+ * surfaced in the chat mention popover and `⌘K` palette.
+ *
+ * Mirrors `use-pinned-entries.ts`: fetches once on mount, keeps an
+ * in-memory list, and writes back via PUT on every mutation (full-list
+ * replacement — see `src/app/api/settings/chat/saved-searches/route.ts`
+ * for design rationale).
+ */
+
+import { useCallback, useEffect, useState } from "react";
+
+export type SavedSearchSurface =
+  | "task"
+  | "project"
+  | "workflow"
+  | "document"
+  | "skill"
+  | "profile";
+
+export interface SavedSearch {
+  id: string;
+  surface: SavedSearchSurface;
+  label: string;
+  filterInput: string;
+  createdAt: string;
+}
+
+interface UseSavedSearchesReturn {
+  searches: SavedSearch[];
+  loading: boolean;
+  save: (entry: Omit<SavedSearch, "id" | "createdAt">) => SavedSearch;
+  remove: (id: string) => void;
+  forSurface: (surface: SavedSearchSurface) => SavedSearch[];
+  /**
+   * Re-fetch from the server. Each `useSavedSearches()` consumer holds
+   * its own state — the chat popover and the ⌘K palette do not share a
+   * cache. Components that need to see edits made elsewhere (e.g. the
+   * palette opening after a save in the popover) call `refetch()` at
+   * the right moment to revalidate.
+   *
+   * See features/saved-search-polish-v1.md for the bug history.
+   */
+  refetch: () => Promise<void>;
+  rename: (id: string, label: string) => void;
+}
+
+export function useSavedSearches(): UseSavedSearchesReturn {
+  const [searches, setSearches] = useState<SavedSearch[]>([]);
+  const [loading, setLoading] = useState(true);
+
+  // Single fetch helper used by both the mount effect and `refetch`.
+  // Returns void so consumers can `await` revalidation if they want
+  // to wait for fresh data before continuing.
+  const fetchSearches = useCallback(async (): Promise<void> => {
+    try {
+      const r = await fetch("/api/settings/chat/saved-searches");
+      const data: { searches?: SavedSearch[] } = r.ok
+        ? await r.json()
+        : { searches: [] };
+      setSearches(data.searches ?? []);
+    } catch {
+      setSearches([]);
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    void fetchSearches();
+  }, [fetchSearches]);
+
+  const persist = useCallback(async (next: SavedSearch[]) => {
+    try {
+      await fetch("/api/settings/chat/saved-searches", {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ searches: next }),
+      });
+    } catch {
+      // Optimistic update already applied; server-sync failure silently
+      // swallowed. Matches the pins-hook contract.
+    }
+  }, []);
+
+  const save = useCallback(
+    (entry: Omit<SavedSearch, "id" | "createdAt">): SavedSearch => {
+      const full: SavedSearch = {
+        ...entry,
+        id:
+          typeof crypto !== "undefined" && "randomUUID" in crypto
+            ? crypto.randomUUID()
+            : `ss-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        createdAt: new Date().toISOString(),
+      };
+      setSearches((prev) => {
+        const next = [...prev, full];
+        void persist(next);
+        return next;
+      });
+      return full;
+    },
+    [persist]
+  );
+
+  const remove = useCallback(
+    (id: string) => {
+      setSearches((prev) => {
+        const next = prev.filter((s) => s.id !== id);
+        void persist(next);
+        return next;
+      });
+    },
+    [persist]
+  );
+
+  const forSurface = useCallback(
+    (surface: SavedSearchSurface) =>
+      searches.filter((s) => s.surface === surface),
+    [searches]
+  );
+
+  const refetch = useCallback(() => fetchSearches(), [fetchSearches]);
+
+  const rename = useCallback(
+    (id: string, label: string) => {
+      setSearches((prev) => {
+        const idx = prev.findIndex((s) => s.id === id);
+        if (idx === -1) return prev;
+        const next = prev.slice();
+        next[idx] = { ...next[idx], label };
+        void persist(next);
+        return next;
+      });
+    },
+    [persist]
+  );
+
+  return { searches, loading, save, remove, forSurface, refetch, rename };
+}

package/src/instrumentation-node.ts

@@ -0,0 +1,94 @@
+export async function registerNodeInstrumentation() {
+  try {
+    // Instance bootstrap — creates local branch, handles dev-mode gates, consent flow.
+    // Runs BEFORE other startup so instance config is available downstream.
+    // Safe in the canonical stagent dev repo thanks to STAGENT_DEV_MODE=true
+    // in .env.local plus the .git/stagent-dev-mode sentinel file.
+    const { ensureInstance } = await import("@/lib/instance/bootstrap");
+    const instanceResult = await ensureInstance();
+    if (instanceResult.skipped) {
+      console.log(`[instance] bootstrap skipped: ${instanceResult.skipped}`);
+    } else {
+      for (const step of instanceResult.steps) {
+        if (step.status === "failed") {
+          console.error(`[instance] ${step.step} failed: ${step.reason}`);
+        }
+      }
+    }
+
+    // Run pending Drizzle migrations (DROP TABLE, CREATE INDEX, etc.)
+    // that can't be handled by bootstrap's IF NOT EXISTS pattern.
+    // Runs here (not in db/index.ts) to avoid SQLITE_BUSY during next build.
+    await runPendingMigrations();
+
+    // Instance upgrade poller — hourly `git fetch` to detect upstream commits.
+    // Skipped in dev mode; lightweight; uses advisory lock to prevent overlap.
+    const { startUpgradePoller } = await import("@/lib/instance/upgrade-poller");
+    startUpgradePoller();
+
+    const { startScheduler } = await import("@/lib/schedules/scheduler");
+    startScheduler();
+
+    const { startChannelPoller } = await import("@/lib/channels/poller");
+    startChannelPoller();
+
+    const { startAutoBackup } = await import("@/lib/snapshots/auto-backup");
+    startAutoBackup();
+
+    // History retention cleanup — prunes old agent_logs and usage_ledger
+    startHistoryCleanup();
+
+  } catch (err) {
+    console.error("Instrumentation startup failed:", err);
+  }
+}
+
+async function startHistoryCleanup() {
+  const CLEANUP_INTERVAL = 24 * 60 * 60 * 1000;
+  const RETENTION_DAYS = 365;
+
+  async function cleanup() {
+    const { db } = await import("@/lib/db");
+    const { agentLogs, usageLedger } = await import("@/lib/db/schema");
+    const { lt } = await import("drizzle-orm");
+
+    const cutoff = new Date(Date.now() - RETENTION_DAYS * 24 * 60 * 60 * 1000);
+    db.delete(agentLogs).where(lt(agentLogs.timestamp, cutoff)).run();
+    db.delete(usageLedger).where(lt(usageLedger.startedAt, cutoff)).run();
+  }
+
+  cleanup().catch(() => {});
+  setInterval(() => cleanup().catch(() => {}), CLEANUP_INTERVAL);
+}
+
+async function runPendingMigrations() {
+  const { join } = await import("path");
+  const { existsSync } = await import("fs");
+  const { getAppRoot } = await import("@/lib/utils/app-root");
+
+  const appRoot = getAppRoot(import.meta.dirname, 1);
+  const migrationsDir = join(appRoot, "src", "lib", "db", "migrations");
+  if (!existsSync(migrationsDir)) return; // npx distribution — no migration files
+
+  const { sqlite } = await import("@/lib/db");
+  const { drizzle } = await import("drizzle-orm/better-sqlite3");
+  const { migrate } = await import("drizzle-orm/better-sqlite3/migrator");
+  const {
+    hasLegacyStagentTables,
+    hasMigrationHistory,
+    markAllMigrationsApplied,
+    bootstrapStagentDatabase,
+  } = await import("@/lib/db/bootstrap");
+
+  const needsLegacyRecovery =
+    hasLegacyStagentTables(sqlite) && !hasMigrationHistory(sqlite);
+
+  if (needsLegacyRecovery) {
+    bootstrapStagentDatabase(sqlite);
+    markAllMigrationsApplied(sqlite, migrationsDir);
+    console.log("[db] Recovered legacy database — all migrations stamped.");
+  } else {
+    const db = drizzle(sqlite);
+    migrate(db, { migrationsFolder: migrationsDir });
+  }
+}

package/src/instrumentation.ts

@@ -1,51 +1,7 @@
-export async function register() {
-  // Only start background services on the server (not during build or edge)
-  if (process.env.NEXT_RUNTIME === "nodejs") {
-    try {
-      // License manager — initialize from DB (creates default row if needed)
-      const { licenseManager } = await import("@/lib/license/manager");
-      licenseManager.initialize();
-      licenseManager.startValidationTimer();
-
-      const { startScheduler } = await import("@/lib/schedules/scheduler");
-      startScheduler();
-
-      const { startChannelPoller } = await import("@/lib/channels/poller");
-      startChannelPoller();
-
-      const { startAutoBackup } = await import("@/lib/snapshots/auto-backup");
-      startAutoBackup();
-
-      // History retention cleanup — prunes old agent_logs and usage_ledger
-      // based on tier retention limit (Community: 30 days)
-      startHistoryCleanup(licenseManager);
-
-      // Telemetry batch flush (opt-in, every 5 minutes)
-      const { startTelemetryFlush } = await import("@/lib/telemetry/queue");
-      startTelemetryFlush();
-    } catch (err) {
-      console.error("Instrumentation startup failed:", err);
-    }
-  }
-}
-
-async function startHistoryCleanup(licenseManager: { getLimit: (r: "historyRetentionDays") => number }) {
-  const CLEANUP_INTERVAL = 24 * 60 * 60 * 1000; // 24 hours
-
-  async function cleanup() {
-    const retentionDays = licenseManager.getLimit("historyRetentionDays");
-    if (!Number.isFinite(retentionDays)) return; // Unlimited retention
-
-    const { db } = await import("@/lib/db");
-    const { agentLogs, usageLedger } = await import("@/lib/db/schema");
-    const { lt } = await import("drizzle-orm");
-
-    const cutoff = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1000);
-    db.delete(agentLogs).where(lt(agentLogs.timestamp, cutoff)).run();
-    db.delete(usageLedger).where(lt(usageLedger.startedAt, cutoff)).run();
+export function register() {
+  if (process.env.NEXT_RUNTIME !== "nodejs") {
+    return;
   }
 
-  // Run once at startup, then daily
-  cleanup().catch(() => {});
-  setInterval(() => cleanup().catch(() => {}), CLEANUP_INTERVAL);
+  return require("./instrumentation-node").registerNodeInstrumentation();
 }

package/src/lib/agents/__tests__/claude-agent-sdk-options.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect } from "vitest";
+import * as fs from "fs";
+import * as path from "path";
+
+describe("claude-agent.ts SDK options parity with chat engine", () => {
+  const agentSource = fs.readFileSync(
+    path.resolve(__dirname, "../claude-agent.ts"),
+    "utf8",
+  );
+
+  // Split the source at the resumeClaudeTask function boundary. The first
+  // half contains executeClaudeTask's query() block; the second half contains
+  // resumeClaudeTask's query() block. This is more robust than a single
+  // regex over the whole file — a future edit that adds a stray `canUseTool`
+  // reference above either function won't cause a parity test to match the
+  // wrong query() call.
+  const resumeMarker = "export async function resumeClaudeTask";
+  const splitIndex = agentSource.indexOf(resumeMarker);
+  if (splitIndex === -1) {
+    throw new Error(
+      "claude-agent-sdk-options.test.ts: could not find `" + resumeMarker +
+      "` in claude-agent.ts — rename or refactor broke this test's assumptions",
+    );
+  }
+  const executeSection = agentSource.slice(0, splitIndex);
+  const resumeSection = agentSource.slice(splitIndex);
+
+  it("imports CLAUDE_SDK_ALLOWED_TOOLS from runtime/claude-sdk", () => {
+    expect(agentSource).toMatch(/CLAUDE_SDK_ALLOWED_TOOLS[\s\S]*runtime\/claude-sdk/);
+  });
+
+  it("imports CLAUDE_SDK_SETTING_SOURCES from runtime/claude-sdk", () => {
+    expect(agentSource).toMatch(/CLAUDE_SDK_SETTING_SOURCES[\s\S]*runtime\/claude-sdk/);
+  });
+
+  it("imports getFeaturesForModel to gate native-skill options", () => {
+    expect(agentSource).toMatch(/getFeaturesForModel/);
+  });
+
+  it("passes settingSources inside executeClaudeTask query() options", () => {
+    // The execute section must contain a query( call AND settingSources.
+    expect(executeSection).toMatch(/query\(/);
+    expect(executeSection).toContain("settingSources");
+  });
+
+  it("passes settingSources inside resumeClaudeTask query() options", () => {
+    expect(resumeSection).toMatch(/query\(/);
+    expect(resumeSection).toContain("settingSources");
+  });
+
+  it("hooks field is NOT present in either query() options block", () => {
+    for (const section of [executeSection, resumeSection]) {
+      expect(section).not.toMatch(/\bhooks\s*:/);
+    }
+  });
+});

package/src/lib/agents/__tests__/claude-agent.test.ts

@@ -141,10 +141,16 @@ vi.mock("@/lib/agents/browser-mcp", () => ({
   isExaTool: vi.fn().mockReturnValue(false),
   isExaReadOnly: vi.fn().mockReturnValue(false),
 }));
+vi.mock("@/lib/chat/stagent-tools", () => ({
+  createToolServer: vi.fn((_projectId?: string | null) => ({
+    asMcpServer: () => ({ __mockStagentServer: true }),
+  })),
+}));
 
 // Static imports (works because vi.mock is hoisted)
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { executeClaudeTask, resumeClaudeTask } from "../claude-agent";
+import { createToolServer } from "@/lib/chat/stagent-tools";
 
 const mockQuery = vi.mocked(query);
 
@@ -238,6 +244,85 @@ describe("executeClaudeTask", () => {
     expect(mockRemoveExecution).toHaveBeenCalledWith("task-1");
   });
 
+  it("A-stagent-1: injects stagent MCP server into query mcpServers", async () => {
+    mockWhere.mockResolvedValueOnce([makeTask({ projectId: "proj-7" })]);
+    mockQuery.mockReturnValue(
+      createMockStream([
+        { type: "result", result: "done" },
+      ]) as unknown as ReturnType<typeof query>
+    );
+
+    await executeClaudeTask("task-1");
+
+    const queryCall = mockQuery.mock.calls[0][0] as {
+      options: { mcpServers?: Record<string, unknown> };
+    };
+    expect(queryCall.options.mcpServers).toBeDefined();
+    expect(queryCall.options.mcpServers!.stagent).toEqual({ __mockStagentServer: true });
+    expect(vi.mocked(createToolServer)).toHaveBeenCalledWith("proj-7");
+  });
+
+  it("A-stagent-2: prepends mcp__stagent__* when profile has allowedTools", async () => {
+    mockWhere.mockResolvedValueOnce([makeTask({ projectId: "proj-7" })]);
+    mockGetProfile.mockReturnValueOnce({
+      id: "restricted",
+      name: "Restricted",
+      systemPrompt: "",
+      allowedTools: ["Read", "Grep"],
+    });
+    mockQuery.mockReturnValue(
+      createMockStream([
+        { type: "result", result: "done" },
+      ]) as unknown as ReturnType<typeof query>
+    );
+
+    await executeClaudeTask("task-1");
+
+    const queryCall = mockQuery.mock.calls[0][0] as {
+      options: { allowedTools?: string[] };
+    };
+    expect(queryCall.options.allowedTools).toBeDefined();
+    expect(queryCall.options.allowedTools).toContain("mcp__stagent__*");
+    expect(queryCall.options.allowedTools).toContain("Read");
+    expect(queryCall.options.allowedTools).toContain("Grep");
+    // Duplicates not added when profile didn't already include the pattern
+    const stagentCount = queryCall.options.allowedTools!.filter(
+      (t) => t === "mcp__stagent__*"
+    ).length;
+    expect(stagentCount).toBe(1);
+  });
+
+  it("A-stagent-3: falls back to CLAUDE_SDK_ALLOWED_TOOLS when profile has none and runtime has native skills", async () => {
+    mockWhere.mockResolvedValueOnce([makeTask({ projectId: "proj-7" })]);
+    // Default mockGetProfile returns allowedTools: undefined. Task-runtime-skill-parity
+    // (Task 3) changed withStagentAllowedTools so the Phase 1a tool set (Skill,
+    // Read/Grep/Glob, Edit/Write/Bash, TodoWrite) is passed alongside mcp__stagent__*
+    // when the runtime has hasNativeSkills=true — which is the claude-code default.
+    mockQuery.mockReturnValue(
+      createMockStream([
+        { type: "result", result: "done" },
+      ]) as unknown as ReturnType<typeof query>
+    );
+
+    await executeClaudeTask("task-1");
+
+    const queryCall = mockQuery.mock.calls[0][0] as {
+      options: { allowedTools?: string[] };
+    };
+    expect(queryCall.options.allowedTools).toBeDefined();
+    expect(queryCall.options.allowedTools).toEqual([
+      "mcp__stagent__*",
+      "Skill",
+      "Read",
+      "Grep",
+      "Glob",
+      "Edit",
+      "Write",
+      "Bash",
+      "TodoWrite",
+    ]);
+  });
+
   it("A3: captures sessionId from init message and re-calls setExecution", async () => {
     mockWhere.mockResolvedValueOnce([makeTask()]);
     mockQuery.mockReturnValue(
@@ -337,6 +422,51 @@ describe("executeClaudeTask", () => {
     expect(callOptions.maxTurns).toBeDefined();
     expect(callOptions.maxBudgetUsd).toBeDefined();
   });
+
+  it("A8: waits for learned-pattern extraction before final cleanup", async () => {
+    let resolveAnalysis: (() => void) | null = null;
+    mockWhere.mockResolvedValueOnce([makeTask()]);
+    mockQuery.mockReturnValue(
+      createMockStream([{ type: "result", result: "done" }]) as unknown as ReturnType<typeof query>
+    );
+    mockAnalyzeForLearnedPatterns.mockReturnValueOnce(
+      new Promise((resolve) => {
+        resolveAnalysis = () => resolve(null);
+      })
+    );
+
+    const runPromise = executeClaudeTask("task-1");
+    await vi.waitFor(() => {
+      expect(mockAnalyzeForLearnedPatterns).toHaveBeenCalledWith("task-1", "general");
+    });
+
+    expect(mockRemoveExecution).not.toHaveBeenCalled();
+
+    resolveAnalysis?.();
+    await runPromise;
+
+    expect(mockRemoveExecution).toHaveBeenCalledWith("task-1");
+  });
+
+  it("A9: logs learned-pattern extraction failures without failing the task", async () => {
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    mockWhere.mockResolvedValueOnce([makeTask()]);
+    mockQuery.mockReturnValue(
+      createMockStream([{ type: "result", result: "done" }]) as unknown as ReturnType<typeof query>
+    );
+    mockAnalyzeForLearnedPatterns.mockRejectedValueOnce(new Error("extract failed"));
+
+    await executeClaudeTask("task-1");
+
+    expect(mockSet).toHaveBeenCalledWith(
+      expect.objectContaining({ status: "completed", result: "done" })
+    );
+    expect(errorSpy).toHaveBeenCalledWith(
+      "[self-improvement] pattern extraction failed:",
+      expect.any(Error)
+    );
+    errorSpy.mockRestore();
+  });
 });
 
 // ═══════════════════════════════════════════════════════════════════════
@@ -527,6 +657,88 @@ describe("resumeClaudeTask", () => {
       expect.objectContaining({ event: "error" })
     );
   });
+
+  it("C5: waits for learned-pattern extraction before final cleanup on resume", async () => {
+    let resolveAnalysis: (() => void) | null = null;
+    mockWhere.mockResolvedValueOnce([
+      makeTask({ sessionId: "sess-123", resumeCount: 0 }),
+    ]);
+    mockQuery.mockReturnValue(
+      createMockStream([{ type: "result", result: "resumed ok" }]) as unknown as ReturnType<typeof query>
+    );
+    mockAnalyzeForLearnedPatterns.mockReturnValueOnce(
+      new Promise((resolve) => {
+        resolveAnalysis = () => resolve(null);
+      })
+    );
+
+    const runPromise = resumeClaudeTask("task-1");
+    await vi.waitFor(() => {
+      expect(mockAnalyzeForLearnedPatterns).toHaveBeenCalledWith("task-1", "general");
+    });
+
+    expect(mockRemoveExecution).not.toHaveBeenCalled();
+
+    resolveAnalysis?.();
+    await runPromise;
+
+    expect(mockRemoveExecution).toHaveBeenCalledWith("task-1");
+  });
+
+  it("R-stagent-1: injects stagent MCP server into query mcpServers on resume", async () => {
+    mockWhere.mockResolvedValueOnce([
+      makeTask({
+        projectId: "proj-7",
+        sessionId: "session-abc",
+        resumeCount: 1,
+      }),
+    ]);
+    mockQuery.mockReturnValue(
+      createMockStream([
+        { type: "result", result: "resumed and done" },
+      ]) as unknown as ReturnType<typeof query>
+    );
+
+    await resumeClaudeTask("task-1");
+
+    const queryCall = mockQuery.mock.calls[0][0] as {
+      options: { mcpServers?: Record<string, unknown>; resume?: string };
+    };
+    expect(queryCall.options.resume).toBe("session-abc");
+    expect(queryCall.options.mcpServers).toBeDefined();
+    expect(queryCall.options.mcpServers!.stagent).toEqual({ __mockStagentServer: true });
+    expect(vi.mocked(createToolServer)).toHaveBeenCalledWith("proj-7");
+  });
+
+  it("R-stagent-2: prepends mcp__stagent__* on resume when profile has allowedTools", async () => {
+    mockWhere.mockResolvedValueOnce([
+      makeTask({
+        projectId: "proj-7",
+        sessionId: "session-abc",
+        resumeCount: 1,
+      }),
+    ]);
+    mockGetProfile.mockReturnValueOnce({
+      id: "restricted",
+      name: "Restricted",
+      systemPrompt: "",
+      allowedTools: ["Read", "Grep"],
+    });
+    mockQuery.mockReturnValue(
+      createMockStream([
+        { type: "result", result: "resumed and done" },
+      ]) as unknown as ReturnType<typeof query>
+    );
+
+    await resumeClaudeTask("task-1");
+
+    const queryCall = mockQuery.mock.calls[0][0] as {
+      options: { allowedTools?: string[] };
+    };
+    expect(queryCall.options.allowedTools).toContain("mcp__stagent__*");
+    expect(queryCall.options.allowedTools).toContain("Read");
+    expect(queryCall.options.allowedTools![0]).toBe("mcp__stagent__*");
+  });
 });
 
 // ═══════════════════════════════════════════════════════════════════════

package/src/lib/agents/__tests__/execution-manager.test.ts

@@ -1,22 +1,10 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-
-vi.mock("@/lib/license/manager", () => ({
-  licenseManager: {
-    getLimit: vi.fn().mockReturnValue(Infinity),
-    getTier: vi.fn().mockReturnValue("scale"),
-  },
-}));
-
-vi.mock("@/lib/license/notifications", () => ({
-  createTierLimitNotification: vi.fn().mockResolvedValue(undefined),
-}));
+import { describe, it, expect, beforeEach } from "vitest";
 
 import {
   getExecution,
   setExecution,
   removeExecution,
   getAllExecutions,
-  ParallelLimitError,
 } from "@/lib/agents/execution-manager";
 
 function makeExecution(taskId: string) {
@@ -73,18 +61,4 @@ describe("execution-manager", () => {
   it("removing non-existent task does not throw", () => {
     expect(() => removeExecution("nonexistent")).not.toThrow();
   });
-
-  it("throws ParallelLimitError when limit is reached", async () => {
-    const { licenseManager } = await import("@/lib/license/manager");
-    (licenseManager.getLimit as ReturnType<typeof vi.fn>).mockReturnValue(2);
-    (licenseManager.getTier as ReturnType<typeof vi.fn>).mockReturnValue("community");
-
-    setExecution("task-1", makeExecution("task-1"));
-    setExecution("task-2", makeExecution("task-2"));
-
-    expect(() => setExecution("task-3", makeExecution("task-3"))).toThrow(ParallelLimitError);
-
-    // Restore unlimited for other tests
-    (licenseManager.getLimit as ReturnType<typeof vi.fn>).mockReturnValue(Infinity);
-  });
 });