@leing2021/super-pi 0.22.0 → 0.22.1

package/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,35 @@
+# 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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,90 @@
+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);
+	});
+});

package/extensions/subagent/agent-management.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult } from "@mariozechner/pi-agent-core";

package/extensions/subagent/agent-manager-chain-detail.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 import type { Theme } from "@mariozechner/pi-coding-agent";
 import { matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
 import type { ChainConfig, ChainStepConfig } from "./agents.ts";

package/extensions/subagent/agent-manager-detail.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 import type { Theme } from "@mariozechner/pi-coding-agent";
 import { matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
 import type { AgentConfig } from "./agents.ts";

package/extensions/subagent/agent-manager-edit.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 import type { Theme } from "@mariozechner/pi-coding-agent";
 import { matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
 import { defaultSystemPromptMode, type AgentConfig, type BuiltinAgentOverrideBase } from "./agents.ts";

package/extensions/subagent/agent-manager-list.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 import type { Theme } from "@mariozechner/pi-coding-agent";
 import type { AgentSource } from "./agents.ts";
 import { matchesKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";

package/extensions/subagent/agent-manager-parallel.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 import type { Theme } from "@mariozechner/pi-coding-agent";
 import { matchesKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
 import type { TextEditorState } from "./text-editor.ts";

package/extensions/subagent/agent-manager.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { Theme } from "@mariozechner/pi-coding-agent";

package/extensions/subagent/agent-scope.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 import type { AgentScope } from "./agents.ts";
 
 export function resolveExecutionAgentScope(scope: unknown): AgentScope {

package/extensions/subagent/agent-selection.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 import type { AgentScope, AgentConfig } from "./agents.ts";
 
 export function mergeAgentsForScope(

package/extensions/subagent/agent-serializer.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 import * as fs from "node:fs";
 import type { AgentConfig } from "./agents.ts";
 

package/extensions/subagent/agent-templates.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 import type { AgentConfig } from "./agents.ts";
 
 export interface AgentTemplate {

package/extensions/subagent/agents.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 /**
  * Agent discovery and configuration
  */

package/extensions/subagent/artifacts.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";

package/extensions/subagent/async-execution.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 /**
  * Async execution logic for subagent tool
  */

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

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -15,6 +16,16 @@ import {
 } from "./types.ts";
 import { readStatus } from "./utils.ts";
 
+/**
+ * Resolve poll interval based on number of running jobs.
+ * Higher parallelism → longer interval to reduce I/O and render pressure.
+ */
+export function resolvePollInterval(runningCount: number): number {
+	if (runningCount <= 2) return 1000;
+	if (runningCount <= 4) return 1500;
+	return 2000;
+}
+
 interface AsyncJobTrackerOptions {
 	completionRetentionMs?: number;
 	pollIntervalMs?: number;
@@ -102,7 +113,7 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 
 	const ensurePoller = () => {
 		if (state.poller) return;
-		state.poller = setInterval(() => {
+		const pollOnce = () => {
 			if (state.asyncJobs.size === 0) {
 				if (state.lastUiContext?.hasUI) rerenderWidget(state.lastUiContext, []);
 				if (state.poller) {
@@ -150,7 +161,20 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 			}
 
 			if (state.lastUiContext?.hasUI) rerenderWidget(state.lastUiContext);
-		}, pollIntervalMs);
+
+			// Dynamically adjust poll interval based on running count
+			const runningCount = Array.from(state.asyncJobs.values()).filter((j) => j.status === "running").length;
+			const adaptiveInterval = resolvePollInterval(runningCount);
+			if (state.poller) {
+				clearInterval(state.poller);
+				state.poller = setInterval(pollOnce, adaptiveInterval);
+				state.poller.unref?.();
+			}
+		};
+
+		const runningCount = Array.from(state.asyncJobs.values()).filter((j) => j.status === "running").length;
+		const initialInterval = resolvePollInterval(runningCount);
+		state.poller = setInterval(pollOnce, initialInterval);
 		state.poller.unref?.();
 	};
 

package/extensions/subagent/async-status.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { formatDuration, formatTokens, shortenPath } from "./formatters.ts";

package/extensions/subagent/chain-clarify.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 /**
  * Chain Clarification TUI Component
  *

package/extensions/subagent/chain-execution.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 /**
  * Chain execution logic for subagent tool
  */

package/extensions/subagent/chain-serializer.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 import type { ChainConfig, ChainStepConfig } from "./agents.ts";
 import { parseFrontmatter } from "./frontmatter.ts";
 

package/extensions/subagent/completion-dedupe.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 interface CompletionDataLike {
 	id?: unknown;
 	agent?: unknown;

package/extensions/subagent/doctor.ts

@@ -1,5 +1,6 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { discoverAgentsAll, type AgentSource } from "./agents.ts";