@leing2021/super-pi 0.22.1 → 0.23.0

package/skills/06-next/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: 06-next
-description: Inspect workflow state and recommend the single best next Compound Engineering skill.
+description: "Inspect workflow state and recommend the single best next Compound Engineering skill. Use --verbose for a full status report."
 ---
 
 # Next
 
-Use this skill when the user wants to know what to run next in the Compound Engineering workflow.
+Use this skill when the user wants to know what to run next in the Compound Engineering workflow, or wants a full status report of the current project state.
 
 ## Core rules
 
@@ -15,18 +15,43 @@ Use this skill when the user wants to know what to run next in the Compound Engi
 - Do not execute the recommended skill — only suggest it.
 - If the workflow state suggests multiple valid paths, pick the one closest to completing a full loop.
 
-## Workflow
+## Two modes
+
+### Default mode: "what's next?"
+
+When the user asks "what should I do next?", "continue", or runs `/skill:06-next`:
+
+1. Call `workflow_state` with the repo root.
+2. Apply the recommendation logic from `references/recommendation-logic.md`.
+3. Return:
+   - **Recommended skill name**
+   - **Why** this is the next step
+   - **Brief** summary of current workflow state (1-2 lines)
+
+### Verbose mode: "full status"
+
+When the user asks "show status", "what's the current state", or explicitly requests a detailed report:
 
 1. Call `workflow_state` with the repo root.
-2. Read the structured state: brainstorm count, plan count, solution count, run count, and latest artifact per category.
-3. Apply the recommendation logic from `references/recommendation-logic.md`.
-4. Return the recommended skill and why.
+2. Call `session_history` with `latest` operation to check recent executions.
+3. Return:
+   - Latest relevant brainstorm (path + brief summary)
+   - Latest relevant plan (path + brief summary)
+   - Latest relevant solution (path + brief summary)
+   - Latest runtime artifacts under `.context/compound-engineering/`
+   - Recommended next step with reason
+   - Overall workflow phase summary
 
-## Output format
+## Artifact locations
 
-- Recommended skill name
-- Why this is the next step
-- Brief summary of current workflow state
+| Artifact | Path |
+|---|---|
+| Brainstorm | `docs/brainstorms/` |
+| Plan | `docs/plans/` |
+| Solution | `docs/solutions/` |
+| Runtime | `.context/compound-engineering/` |
+
+If `workflow_state` is not available, fall back to `bash` with `ls` and `find` to check which directories and recent files exist, then use `read` on the most relevant recent artifact.
 
 ## Available skills
 
@@ -35,3 +60,6 @@ Use this skill when the user wants to know what to run next in the Compound Engi
 - `03-work` — execute the plan
 - `04-review` — review changes with structured findings
 - `05-learn` — capture learnings as solution artifacts
+- `07-worktree` — isolated git worktree development
+
+Before finishing this skill, apply the completion checklist in [shared pipeline instructions](../references/pipeline-config.md).

package/skills/06-next/references/recommendation-logic.md

@@ -42,5 +42,5 @@ If brainstorm, plan, and solution all exist:
 ## Fallback
 
 If no rule matches cleanly:
-- Recommend `08-status`
-- Reason: State is ambiguous. Get a detailed report before deciding.
+- Summarize the ambiguous state
+- Ask the user what they want to focus on

package/skills/07-worktree/SKILL.md

@@ -3,25 +3,26 @@ name: 07-worktree
 description: Create and manage git worktrees for isolated feature development.
 ---
 
-# 03-worktree
+# Worktree
 
-Use this skill when you need to create an isolated git worktree for feature work, merge changes back, or clean up after completion.
+Use this skill when you need optional isolated git worktree development for large, risky, or parallel feature work, then merge changes back or clean up after completion.
 
 ## Core rules
 
 - Use the `worktree_manager` tool for all git worktree operations.
-- Default behavior is to **automatically create** a worktree with a descriptive branch name derived from the plan or task.
+- Create a worktree only when the user explicitly asks for isolation, or when the task is large/risky enough and the user confirms.
+- Use a descriptive branch name derived from the plan or task.
 - After creation, report the worktree path so that `03-work` can execute inside it.
-- On completion, merge back and clean up.
+- On completion, offer to merge back and clean up; ask for confirmation before changing the main worktree or deleting branches.
 - Never force operations — if a worktree already exists, report its status instead of creating a duplicate.
 
 ## Workflow
 
-1. **Create**: Use `worktree_manager` with operation `create` to spin up a new worktree with a feature branch.
-2. **Detect**: Use `worktree_manager` with operation `detect` to check if already inside a worktree.
+1. **Detect**: Use `worktree_manager` with operation `detect` to check if already inside a worktree.
+2. **Create**: When confirmed, use `worktree_manager` with operation `create` to spin up a new worktree with a feature branch.
 3. **Execute**: Run `03-work` inside the worktree directory.
-4. **Merge**: Use `worktree_manager` with operation `merge` to merge the feature branch back to main.
-5. **Cleanup**: Use `worktree_manager` with operation `cleanup` to remove the worktree and delete the branch.
+4. **Merge**: After user confirmation, use `worktree_manager` with operation `merge` to merge the feature branch back to main.
+5. **Cleanup**: After user confirmation, use `worktree_manager` with operation `cleanup` to remove the worktree and delete the branch.
 
 ## Output
 

package/skills/{09-help → 08-help}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: 09-help
+name: 08-help
 description: Explain when to use each Compound Engineering Phase 1 skill and how they connect.
 ---
 
@@ -14,7 +14,7 @@ Use this skill when the user asks how to use the package, which workflow step co
 - `03-work` — use when there is a plan or a tightly scoped task ready for controlled execution.
 - `04-review` — use after code changes to produce structured findings. After code review, user can optionally extend to browser-based QA testing (find visual/functional bugs with agent-browser) and regression test generation.
 - `05-learn` — use after solving a problem so the repo gains a durable learning in `docs/solutions/`.
-- `08-status` — use when the user wants to know which artifact already exists and what the next workflow step should be.
+- `06-next` — use when the user wants to know what to run next, or wants a full status report of the current project state. Default mode recommends one next step; verbose mode (`--verbose` or ask "show status") shows full artifact details.
 
 ## Recommended flow
 
@@ -30,7 +30,7 @@ Use this skill when the user asks how to use the package, which workflow step co
    - Optionally extend to **Browser QA** for visual and functional bug finding.
    - Or **Browser QA + Regression Tests** to also generate automated test coverage.
 5. Capture key learnings with `05-learn`.
-6. Use `08-status` at any point to inspect repo-local workflow state.
+6. Use `06-next` at any point to check what to do next, or ask for a full status report.
 
 ## Output
 

package/skills/{09-help → 08-help}/references/workflow-sequence.md

@@ -6,4 +6,5 @@
 4. `04-review` → inspect the changes (optionally + Browser QA / QA + Regression Tests)
 5. `05-learn` → save key learnings
 
-Use `08-status` at any point to see where you are.
+Use `06-next` at any point to see where you are and what to do next.
+Use `07-worktree` for isolated feature development on a separate branch.

package/skills/references/language-detection.md

@@ -0,0 +1,44 @@
+# Language Detection
+
+Detect the project's primary language by checking for these files in the repo root:
+
+| File(s) | Language | Rules directory |
+|---------|----------|----------------|
+| `tsconfig.json` | TypeScript | `rules/typescript/` |
+| `package.json` (without `tsconfig.json`) | JavaScript | `rules/typescript/` |
+| `Cargo.toml` | Rust | `rules/rust/` |
+| `go.mod` | Go | `rules/golang/` |
+| `pubspec.yaml` | Dart | `rules/dart/` |
+| `pom.xml` / `build.gradle` | Java | `rules/java/` |
+| `*.sln` / `*.csproj` | C# | `rules/csharp/` |
+| `Package.swift` | Swift | `rules/swift/` |
+| `requirements.txt` / `pyproject.toml` / `setup.py` | Python | `rules/python/` |
+| `composer.json` | PHP | `rules/php/` |
+| `Makefile.PL` / `cpanfile` | Perl | `rules/perl/` |
+| `build.gradle.kts` | Kotlin | `rules/kotlin/` |
+
+## Rules loading strategy
+
+Rules are loaded from two locations with priority:
+
+1. **Project-level** `{repo-root}/rules/` — takes priority, survives `pi update`.
+2. **Package-level** `rules/` in the super-pi package — built-in defaults.
+
+Check project-level first. If a file exists there for the topic, use it. Otherwise fall back to package-level.
+
+## Rule precedence
+
+```
+language-specific > web > common
+```
+
+Override mapping by topic:
+- `common/testing.md` ← `web/testing.md` ← `<lang>/testing.md`
+- `common/coding-style.md` ← `web/coding-style.md` ← `<lang>/coding-style.md`
+- `common/patterns.md` ← `web/patterns.md` ← `<lang>/patterns.md`
+- `common/security.md` ← `web/security.md` ← `<lang>/security.md`
+- `common/hooks.md` ← `web/hooks.md` ← `<lang>/hooks.md`
+
+## Do not load all rules at once
+
+Only load what the current task needs. See each skill's SKILL.md for phase-specific loading instructions.

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025-2026 leing2021
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/THIRD-PARTY-NOTICES.md

@@ -1,35 +0,0 @@
-# Third-Party Notices
-
-## pi-subagents
-
-This software includes source code from the **pi-subagents** project.
-
-- **Author**: Nico Bailon
-- **Repository**: https://github.com/nicobailon/pi-subagents
-- **License**: MIT
-
-```
-MIT License
-
-Copyright (c) 2025 Nico Bailon
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-```
-
-The pi-subagents source code is located in `extensions/subagent/`.

package/extensions/subagent/__tests__/async-job-tracker.test.ts

@@ -1,21 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { resolvePollInterval } from "../async-job-tracker.ts";
-
-describe("resolvePollInterval", () => {
-	it("returns 1000ms as default (no running jobs)", () => {
-		expect(resolvePollInterval(0)).toBe(1000);
-		expect(resolvePollInterval(1)).toBe(1000);
-		expect(resolvePollInterval(2)).toBe(1000);
-	});
-
-	it("returns 1500ms for 3-4 running jobs", () => {
-		expect(resolvePollInterval(3)).toBe(1500);
-		expect(resolvePollInterval(4)).toBe(1500);
-	});
-
-	it("returns 2000ms for 5+ running jobs", () => {
-		expect(resolvePollInterval(5)).toBe(2000);
-		expect(resolvePollInterval(8)).toBe(2000);
-		expect(resolvePollInterval(16)).toBe(2000);
-	});
-});

package/extensions/subagent/__tests__/execution-activity.test.ts

@@ -1,15 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { resolveActivityTimerInterval } from "../execution.ts";
-
-describe("resolveActivityTimerInterval", () => {
-	it("returns 2000ms as default (single subprocess)", () => {
-		expect(resolveActivityTimerInterval()).toBe(2000);
-		expect(resolveActivityTimerInterval(1)).toBe(2000);
-	});
-
-	it("returns 3000ms for parallel scenarios (2+ concurrent)", () => {
-		expect(resolveActivityTimerInterval(2)).toBe(3000);
-		expect(resolveActivityTimerInterval(4)).toBe(3000);
-		expect(resolveActivityTimerInterval(8)).toBe(3000);
-	});
-});

package/extensions/subagent/__tests__/parallel-render-stress.test.ts

@@ -1,82 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "bun:test";
-import { createThrottle, resolveThrottleInterval } from "../throttle.ts";
-import { resolveWidgetInterval } from "../render.ts";
-import { resolveActivityTimerInterval } from "../execution.ts";
-import { resolvePollInterval } from "../async-job-tracker.ts";
-
-/**
- * Integration stress test: simulates 8 parallel subagents firing events
- * and validates that total render frequency stays within bounds.
- */
-describe("parallel render stress", () => {
-	beforeEach(() => { vi.useFakeTimers(); });
-	afterEach(() => { vi.useRealTimers(); });
-
-	it("limits onUpdate to ≤5 triggers/s with 8 parallel tasks", () => {
-		const interval = resolveThrottleInterval(8);
-		expect(interval).toBe(500);
-
-		const fn = vi.fn();
-		const throttled = createThrottle(fn, interval);
-
-		// Simulate 100 rapid fireUpdate calls in 1ms intervals (like 8 processes sending events)
-		for (let i = 0; i < 100; i++) {
-			throttled({ index: i });
-			vi.advanceTimersByTime(1);
-		}
-
-		// First call executes immediately, then at most 1 call per 500ms
-		// Over 100ms simulated time: 1 (immediate) + ~0 (no 500ms passed yet) = 1 call
-		expect(fn.mock.calls.length).toBeGreaterThanOrEqual(1);
-		expect(fn.mock.calls.length).toBeLessThanOrEqual(2);
-
-		throttled.dispose();
-	});
-
-	it("allows at most 2 calls in 500ms for 8 tasks (500ms throttle)", () => {
-		const interval = resolveThrottleInterval(8);
-		const fn = vi.fn();
-		const throttled = createThrottle(fn, interval);
-
-		// Immediate first call
-		throttled("a");
-		expect(fn).toHaveBeenCalledTimes(1);
-
-		// Fire many more
-		for (let i = 0; i < 50; i++) throttled(`b-${i}`);
-
-		// Advance 500ms — trailing fires
-		vi.advanceTimersByTime(500);
-		expect(fn).toHaveBeenCalledTimes(2); // immediate + 1 trailing
-
-		throttled.dispose();
-	});
-
-	it("widget animation interval adapts to 1000ms at 7+ running jobs", () => {
-		expect(resolveWidgetInterval(7)).toBe(1000);
-		expect(resolveWidgetInterval(8)).toBe(1000);
-	});
-
-	it("activity timer adapts to 3000ms for parallel scenarios", () => {
-		expect(resolveActivityTimerInterval(8)).toBe(3000);
-	});
-
-	it("poll interval adapts to 2000ms at 5+ running jobs", () => {
-		expect(resolvePollInterval(5)).toBe(2000);
-		expect(resolvePollInterval(8)).toBe(2000);
-	});
-
-	it("total theoretical render rate with 8 parallel subagents is ≤ 8/s", () => {
-		const widgetRate = 1000 / resolveWidgetInterval(8);      // renders/s
-		const pollRate = 1000 / resolvePollInterval(8);           // polls/s
-		const throttleRate = 1000 / resolveThrottleInterval(8);   // onUpdate/s
-		const activityRate = 1000 / resolveActivityTimerInterval(8); // activity checks/s
-
-		// Widget animation + poll + onUpdate throttle + activity are the main render sources
-		// Note: not all fire requestRender every time
-		const totalMaxRate = widgetRate + pollRate + throttleRate + activityRate;
-
-		// With all optimizations, should be well under 8/s total
-		expect(totalMaxRate).toBeLessThanOrEqual(8);
-	});
-});

package/extensions/subagent/__tests__/render-dedup.test.ts

@@ -1,98 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "bun:test";
-
-describe("render dedup", () => {
-	beforeEach(async () => {
-		const { _testResetWidgetState } = await import("../render.ts");
-		_testResetWidgetState();
-	});
-
-	it("should not call requestRender when widget data is identical", async () => {
-		const { renderWidget, stopWidgetAnimation } = await import("../render.ts");
-
-		const setWidget = vi.fn();
-		const requestRender = vi.fn();
-		const theme = {
-			fg: (_color: string, text: string) => text,
-			bold: (text: string) => text,
-		};
-		const ctx = {
-			hasUI: true,
-			ui: { setWidget, requestRender, theme },
-		} as any;
-
-		const jobs = [
-			{ asyncId: "test-1", asyncDir: "/tmp/test", status: "complete" as const, updatedAt: 1000 },
-		];
-
-		// First render — should call requestRender (new content)
-		renderWidget(ctx, jobs);
-		expect(requestRender).toHaveBeenCalledTimes(1);
-
-		// Second render with EXACTLY same data — should NOT call requestRender
-		renderWidget(ctx, jobs);
-		expect(requestRender).toHaveBeenCalledTimes(1); // Still 1
-
-		stopWidgetAnimation();
-	});
-
-	it("should call requestRender when widget data changes", async () => {
-		const { renderWidget, stopWidgetAnimation } = await import("../render.ts");
-
-		const setWidget = vi.fn();
-		const requestRender = vi.fn();
-		const theme = {
-			fg: (_color: string, text: string) => text,
-			bold: (text: string) => text,
-		};
-		const ctx = {
-			hasUI: true,
-			ui: { setWidget, requestRender, theme },
-		} as any;
-
-		// First render
-		const jobs1 = [
-			{ asyncId: "test-1", asyncDir: "/tmp/test", status: "running" as const, updatedAt: 1000 },
-		];
-		renderWidget(ctx, jobs1);
-		expect(requestRender).toHaveBeenCalledTimes(1);
-
-		// Second render with changed updatedAt — should call requestRender
-		const jobs2 = [
-			{ asyncId: "test-1", asyncDir: "/tmp/test", status: "running" as const, updatedAt: 2000 },
-		];
-		renderWidget(ctx, jobs2);
-		expect(requestRender).toHaveBeenCalledTimes(2);
-
-		stopWidgetAnimation();
-	});
-
-	it("should call requestRender on status transitions", async () => {
-		const { renderWidget, stopWidgetAnimation } = await import("../render.ts");
-
-		const setWidget = vi.fn();
-		const requestRender = vi.fn();
-		const theme = {
-			fg: (_color: string, text: string) => text,
-			bold: (text: string) => text,
-		};
-		const ctx = {
-			hasUI: true,
-			ui: { setWidget, requestRender, theme },
-		} as any;
-
-		const jobs1 = [
-			{ asyncId: "test-1", asyncDir: "/tmp/test", status: "running" as const, updatedAt: 1000 },
-		];
-		renderWidget(ctx, jobs1);
-		expect(requestRender).toHaveBeenCalledTimes(1);
-
-		// Status changes to complete — should trigger requestRender
-		const jobs2 = [
-			{ asyncId: "test-1", asyncDir: "/tmp/test", status: "complete" as const, updatedAt: 2000 },
-		];
-		renderWidget(ctx, jobs2);
-		expect(requestRender).toHaveBeenCalledTimes(2);
-
-		stopWidgetAnimation();
-	});
-});

package/extensions/subagent/__tests__/render-widget.test.ts

@@ -1,28 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "bun:test";
-import {
-	resolveWidgetInterval,
-} from "../render.ts";
-
-describe("resolveWidgetInterval", () => {
-	it("returns 250ms for 1-2 running jobs", () => {
-		expect(resolveWidgetInterval(0)).toBe(250);
-		expect(resolveWidgetInterval(1)).toBe(250);
-		expect(resolveWidgetInterval(2)).toBe(250);
-	});
-
-	it("returns 400ms for 3-4 running jobs", () => {
-		expect(resolveWidgetInterval(3)).toBe(400);
-		expect(resolveWidgetInterval(4)).toBe(400);
-	});
-
-	it("returns 600ms for 5-6 running jobs", () => {
-		expect(resolveWidgetInterval(5)).toBe(600);
-		expect(resolveWidgetInterval(6)).toBe(600);
-	});
-
-	it("returns 1000ms for 7+ running jobs", () => {
-		expect(resolveWidgetInterval(7)).toBe(1000);
-		expect(resolveWidgetInterval(8)).toBe(1000);
-		expect(resolveWidgetInterval(16)).toBe(1000);
-	});
-});

package/extensions/subagent/__tests__/throttle.test.ts

@@ -1,90 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "bun:test";
-import { createThrottle, resolveThrottleInterval } from "../throttle.ts";
-
-describe("createThrottle", () => {
-	beforeEach(() => { vi.useFakeTimers(); });
-	afterEach(() => { vi.useRealTimers(); });
-
-	it("executes the first call immediately", () => {
-		const fn = vi.fn();
-		const throttled = createThrottle(fn, 200);
-		throttled("a");
-		expect(fn).toHaveBeenCalledTimes(1);
-		expect(fn).toHaveBeenCalledWith("a");
-	});
-
-	it("drops calls within the interval, keeping only the latest args", () => {
-		const fn = vi.fn();
-		const throttled = createThrottle(fn, 200);
-		throttled("a");
-		throttled("b");
-		throttled("c");
-		expect(fn).toHaveBeenCalledTimes(1);
-		expect(fn).toHaveBeenCalledWith("a");
-
-		vi.advanceTimersByTime(200);
-		expect(fn).toHaveBeenCalledTimes(2);
-		expect(fn).toHaveBeenCalledWith("c");
-	});
-
-	it("does not fire trailing call if no pending args", () => {
-		const fn = vi.fn();
-		const throttled = createThrottle(fn, 200);
-		throttled("a");
-		expect(fn).toHaveBeenCalledTimes(1);
-
-		vi.advanceTimersByTime(200);
-		// No new call after "a", so no trailing fire
-		expect(fn).toHaveBeenCalledTimes(1);
-	});
-
-	it("flush() immediately executes the latest pending args", () => {
-		const fn = vi.fn();
-		const throttled = createThrottle(fn, 200);
-		throttled("a");
-		throttled("b");
-		throttled.flush();
-		expect(fn).toHaveBeenCalledTimes(2);
-		expect(fn).toHaveBeenCalledWith("b");
-	});
-
-	it("flush() does nothing if no pending call", () => {
-		const fn = vi.fn();
-		const throttled = createThrottle(fn, 200);
-		throttled.flush();
-		expect(fn).toHaveBeenCalledTimes(0);
-	});
-
-	it("dispose() clears timers and prevents future trailing calls", () => {
-		const fn = vi.fn();
-		const throttled = createThrottle(fn, 200);
-		throttled("a");
-		throttled("b");
-		throttled.dispose();
-		vi.advanceTimersByTime(500);
-		expect(fn).toHaveBeenCalledTimes(1);
-		expect(fn).toHaveBeenCalledWith("a");
-	});
-});
-
-describe("resolveThrottleInterval", () => {
-	it("returns 0 for 1 task (no throttle)", () => {
-		expect(resolveThrottleInterval(1)).toBe(0);
-	});
-
-	it("returns 200ms for 2-4 tasks", () => {
-		expect(resolveThrottleInterval(2)).toBe(200);
-		expect(resolveThrottleInterval(3)).toBe(200);
-		expect(resolveThrottleInterval(4)).toBe(200);
-	});
-
-	it("returns 500ms for 5-8 tasks", () => {
-		expect(resolveThrottleInterval(5)).toBe(500);
-		expect(resolveThrottleInterval(8)).toBe(500);
-	});
-
-	it("returns 1000ms for 9+ tasks", () => {
-		expect(resolveThrottleInterval(9)).toBe(1000);
-		expect(resolveThrottleInterval(16)).toBe(1000);
-	});
-});