@melihmucuk/pi-crew 1.0.17 → 1.0.18

package/extension/tools.ts

@@ -0,0 +1,323 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import { getAgentDir, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+import {
+	discoverAgents,
+	type AgentConfig,
+	type AgentDiscoveryWarning,
+} from "./catalog.js";
+import type { AbortOwnedResult, ActiveAgentSummary, CrewRuntime } from "./crew.js";
+import { STATUS_ICON, renderCrewCall, renderCrewResult, sendCrewListActiveWarning } from "./ui.js";
+
+export type CrewToolResult = AgentToolResult<unknown> & {
+	isError?: boolean;
+	terminate?: boolean;
+};
+
+type RegisteredTool = Parameters<ExtensionAPI["registerTool"]>[0];
+type ToolRenderCall = Exclude<RegisteredTool["renderCall"], undefined>;
+
+interface ToolContext {
+	cwd: string;
+	callerSessionId: string;
+}
+
+function getToolContext(ctx: ExtensionContext): ToolContext {
+	return {
+		cwd: ctx.cwd,
+		callerSessionId: ctx.sessionManager.getSessionId(),
+	};
+}
+
+function toolError(text: string): CrewToolResult {
+	return {
+		content: [{ type: "text", text }],
+		isError: true,
+		details: { error: true },
+	};
+}
+
+function toolSuccess(
+	text: string,
+	details: Record<string, unknown> = {},
+	options: { terminate?: boolean } = {},
+): CrewToolResult {
+	return {
+		content: [{ type: "text", text }],
+		details,
+		...(options.terminate ? { terminate: true } : {}),
+	};
+}
+
+function formatAvailableAgents(agents: AgentConfig[]): string[] {
+	if (agents.length === 0) {
+		return ["No valid subagent definitions found. Add `.md` files to `<cwd>/.pi/agents/` or `~/.pi/agent/agents/`."];
+	}
+
+	return agents.flatMap((agent) => [
+		"",
+		`name: ${agent.name}`,
+		`description: ${agent.description}`,
+		`interactive: ${agent.interactive ? "true" : "false"}`,
+	]);
+}
+
+function formatWarnings(warnings: AgentDiscoveryWarning[]): string[] {
+	if (warnings.length === 0) return [];
+	return [
+		"",
+		"## Ignored subagent definitions",
+		...warnings.map((warning) => `- ${warning.message} (${warning.filePath})`),
+	];
+}
+
+function formatActiveAgents(running: ActiveAgentSummary[]): string[] {
+	if (running.length === 0) return ["No subagents currently active."];
+	return running.flatMap((agent) => {
+		const icon = STATUS_ICON[agent.status] ?? "❓";
+		return ["", `id: ${agent.id}`, `name: ${agent.agentName}`, `status: ${icon} ${agent.status}`];
+	});
+}
+
+function formatAbortToolMessage(result: AbortOwnedResult): string {
+	const parts: string[] = [];
+	if (result.abortedIds.length > 0) parts.push(`Aborted ${result.abortedIds.length} subagent(s): ${result.abortedIds.join(", ")}`);
+	if (result.missingIds.length > 0) parts.push(`Not found or already finished: ${result.missingIds.join(", ")}`);
+	if (result.foreignIds.length > 0) parts.push(`Belong to a different session: ${result.foreignIds.join(", ")}`);
+	return parts.join("\n");
+}
+
+function notifyDiscoveryWarnings(
+	ctx: ExtensionContext,
+	shownDiscoveryWarnings: Set<string>,
+	warnings: AgentDiscoveryWarning[],
+): void {
+	if (!ctx.hasUI) return;
+	for (const warning of warnings) {
+		const key = `${warning.filePath}:${warning.message}`;
+		if (shownDiscoveryWarnings.has(key)) continue;
+		shownDiscoveryWarnings.add(key);
+		ctx.ui.notify(`${warning.message} (${warning.filePath})`, "error");
+	}
+}
+
+function showActiveListWarning(pi: ExtensionAPI, ctx: ExtensionContext): void {
+	Promise.resolve().then(() => {
+		sendCrewListActiveWarning(pi.sendMessage.bind(pi), {
+			isIdle: ctx.isIdle(),
+			triggerTurn: true,
+		});
+	});
+}
+
+function registerActionTool<Params extends object>(
+	pi: ExtensionAPI,
+	options: Omit<RegisteredTool, "execute" | "renderResult" | "renderCall"> & {
+		action: (params: Params, ctx: ExtensionContext) => CrewToolResult;
+		renderCall?: (
+			args: Partial<Params>,
+			theme: Parameters<ToolRenderCall>[1],
+			context: Parameters<ToolRenderCall>[2],
+		) => ReturnType<ToolRenderCall>;
+	},
+): void {
+	const { action, renderCall, ...tool } = options;
+	pi.registerTool({
+		...tool,
+		...(renderCall ? { renderCall: (args, theme, context) => renderCall(args as Partial<Params>, theme, context) } : {}),
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			return action(params as Params, ctx);
+		},
+		renderResult(result, _options, theme, _context) {
+			return renderCrewResult(result, theme);
+		},
+	});
+}
+
+export function registerCrewTools(pi: ExtensionAPI, crew: CrewRuntime, extensionDir: string): void {
+	const shownDiscoveryWarnings = new Set<string>();
+
+	pi.registerTool({
+		name: "crew_list",
+		label: "List Crew",
+		description:
+			"List available subagent definitions and currently running subagents with their status. Use only to discover which subagents exist or to get a one-time status snapshot. Do NOT call this repeatedly to check if a subagent has finished — results are delivered automatically as steering messages.",
+		parameters: Type.Object({}),
+		promptSnippet: "List subagent definitions and active subagents",
+		promptGuidelines: [
+			"crew_list: List available subagents and active subagents owned by this session.",
+			"crew_list: Use before crew_spawn to discover names, descriptions, and interactive status.",
+			"crew_list: Use only for discovery or a requested status snapshot; do not poll for completion.",
+		],
+		async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+			const toolCtx = getToolContext(ctx);
+			const { agents, warnings } = discoverAgents(toolCtx.cwd);
+			const running = crew.getActiveSummariesForOwner(toolCtx.callerSessionId);
+			const lines = [
+				"## Available Subagents",
+				...formatAvailableAgents(agents),
+				...formatWarnings(warnings),
+				"",
+				"## Active Subagents",
+				...formatActiveAgents(running),
+			];
+			notifyDiscoveryWarnings(ctx, shownDiscoveryWarnings, warnings);
+			if (running.length > 0) showActiveListWarning(pi, ctx);
+			return { content: [{ type: "text", text: lines.join("\n") }], details: {} };
+		},
+		renderCall(_args, theme, _context) {
+			return new Text(theme.fg("toolTitle", theme.bold("crew_list")), 0, 0);
+		},
+		renderResult(result, _options, _theme, _context) {
+			const text = result.content[0];
+			return new Text(text?.type === "text" ? text.text : "(no output)", 0, 0);
+		},
+	});
+
+	registerActionTool<{ subagent: string; task: string }>(pi, {
+		name: "crew_spawn",
+		label: "Spawn Crew",
+		description:
+			"Spawn a non-blocking subagent that runs in an isolated session. The subagent works independently while your session stays interactive. Results are delivered back to your session as steering messages.",
+		parameters: Type.Object({
+			subagent: Type.String({ description: "Subagent name from crew_list" }),
+			task: Type.String({ description: "Task to delegate to the subagent" }),
+		}),
+		promptSnippet: "Spawn a non-blocking subagent. Use crew_list first to see available subagents.",
+		promptGuidelines: [
+			"crew_spawn: Spawn a discovered subagent for one clearly delegated, self-contained task.",
+			"crew_spawn: Include only needed context: constraints, relevant files, acceptance criteria, and expected output.",
+			"crew_spawn: After spawning, ownership transfers to the subagent; do not work on that task yourself.",
+			"crew_spawn: Results arrive as steering messages; do not poll crew_list or fabricate results.",
+			"crew_spawn: Use the bundled pi-crew skill for detailed delegation patterns.",
+		],
+		action: (params, ctx) => {
+			const toolCtx = getToolContext(ctx);
+			const { agents, warnings } = discoverAgents(toolCtx.cwd);
+			notifyDiscoveryWarnings(ctx, shownDiscoveryWarnings, warnings);
+			const subagent = agents.find((candidate) => candidate.name === params.subagent);
+			if (!subagent) {
+				const available = agents.map((candidate) => candidate.name).join(", ") || "none";
+				return toolError(`Unknown subagent: "${params.subagent}". Available: ${available}`);
+			}
+
+			const id = crew.spawn(
+				subagent,
+				params.task,
+				toolCtx.cwd,
+				toolCtx.callerSessionId,
+				{
+					model: ctx.model,
+					modelRegistry: ctx.modelRegistry,
+					agentDir: getAgentDir(),
+					parentSessionFile: ctx.sessionManager.getSessionFile(),
+					onWarning: (msg) => ctx.ui.notify(msg, "warning"),
+				},
+				extensionDir,
+			);
+			return toolSuccess(
+				`Subagent '${subagent.name}' spawned as ${id}. Result will be delivered as a steering message when done.`,
+				{ id, agentName: subagent.name, task: params.task },
+			);
+		},
+		renderCall(args, theme, _context) {
+			return renderCrewCall(theme, "crew_spawn", args.subagent || "...", args.task);
+		},
+	});
+
+	registerActionTool<{ subagent_id?: string; subagent_ids?: string[]; all?: boolean }>(pi, {
+		name: "crew_abort",
+		label: "Abort Crew",
+		description: "Abort one, many, or all active subagents owned by the current session.",
+		parameters: Type.Object({
+			subagent_id: Type.Optional(Type.String({ description: "Single subagent ID to abort" })),
+			subagent_ids: Type.Optional(Type.Array(Type.String(), { minItems: 1, description: "Multiple subagent IDs to abort" })),
+			all: Type.Optional(Type.Boolean({ description: "Abort all active subagents owned by the current session" })),
+		}),
+		promptSnippet: "Abort one, many, or all active subagents from this session.",
+		promptGuidelines: [
+			"crew_abort: Abort one, many, or all active subagents owned by this session.",
+			"crew_abort: Provide exactly one mode: subagent_id, subagent_ids, or all=true.",
+			"crew_abort: Use only when delegated work is obsolete, wrong, or explicitly cancelled.",
+		],
+		action: (params, ctx) => {
+			const { callerSessionId } = getToolContext(ctx);
+			const modeCount = Number(Boolean(params.subagent_id)) + Number(Boolean(params.subagent_ids?.length)) + Number(params.all === true);
+			if (modeCount !== 1) return toolError("Provide exactly one of: subagent_id, subagent_ids, or all=true.");
+
+			if (params.all) {
+				const abortedIds = crew.abortAllOwned(callerSessionId, { reason: "Aborted by tool request" });
+				if (abortedIds.length === 0) return toolError("No active subagents in the current session.");
+				return toolSuccess(`Aborted ${abortedIds.length} subagent(s): ${abortedIds.join(", ")}`, { ids: abortedIds }, { terminate: true });
+			}
+
+			const ids = params.subagent_id ? [params.subagent_id] : (params.subagent_ids ?? []);
+			const result = crew.abortOwned(ids, callerSessionId, { reason: "Aborted by tool request" });
+			const message = formatAbortToolMessage(result);
+			if (result.abortedIds.length === 0) return toolError(message || "No subagents were aborted.");
+			return toolSuccess(
+				message,
+				{ ids: result.abortedIds, missing_ids: result.missingIds, foreign_ids: result.foreignIds },
+				{ terminate: true },
+			);
+		},
+		renderCall(args, theme, _context) {
+			if (args.all) return renderCrewCall(theme, "crew_abort", "all");
+			if (args.subagent_id) return renderCrewCall(theme, "crew_abort", args.subagent_id);
+			const count = Array.isArray(args.subagent_ids) ? args.subagent_ids.length : 0;
+			return renderCrewCall(theme, "crew_abort", `${count} ids`);
+		},
+	});
+
+	registerActionTool<{ subagent_id: string; message: string }>(pi, {
+		name: "crew_respond",
+		label: "Respond to Crew",
+		description: "Send a follow-up message to an interactive subagent that is waiting for a response.",
+		parameters: Type.Object({
+			subagent_id: Type.String({ description: "ID of the waiting subagent (from crew_list or crew_spawn result)" }),
+			message: Type.String({ description: "Message to send to the subagent" }),
+		}),
+		promptSnippet: "Send a follow-up message to a waiting interactive subagent.",
+		promptGuidelines: [
+			"crew_respond: Send a complete follow-up message to a waiting interactive subagent.",
+			"crew_respond: Use the waiting subagent ID from crew_spawn results or crew_list.",
+			"crew_respond: The response arrives as a steering message; do not poll crew_list.",
+		],
+		action: (params, ctx) => {
+			const { callerSessionId } = getToolContext(ctx);
+			const { error } = crew.respond(params.subagent_id, params.message, callerSessionId);
+			if (error) return toolError(error);
+			return toolSuccess(
+				`Message sent to subagent ${params.subagent_id}. Response will be delivered as a steering message.`,
+				{ id: params.subagent_id, message: params.message },
+			);
+		},
+		renderCall(args, theme, _context) {
+			return renderCrewCall(theme, "crew_respond", args.subagent_id || "...", args.message);
+		},
+	});
+
+	registerActionTool<{ subagent_id: string }>(pi, {
+		name: "crew_done",
+		label: "Done with Crew",
+		description: "Close an interactive subagent session. Use when you no longer need to interact with the subagent.",
+		parameters: Type.Object({
+			subagent_id: Type.String({ description: "ID of the subagent to close" }),
+		}),
+		promptSnippet: "Close an interactive subagent session when done.",
+		promptGuidelines: [
+			"crew_done: Close a waiting interactive subagent owned by this session.",
+			"crew_done: Use only when no further follow-up is needed; otherwise use crew_respond.",
+		],
+		action: (params, ctx) => {
+			const { callerSessionId } = getToolContext(ctx);
+			const { error } = crew.done(params.subagent_id, callerSessionId);
+			if (error) return toolError(error);
+			return toolSuccess(`Subagent ${params.subagent_id} closed.`, { id: params.subagent_id });
+		},
+		renderCall(args, theme, _context) {
+			return renderCrewCall(theme, "crew_done", args.subagent_id || "...");
+		},
+	});
+}

package/extension/ui.ts

@@ -0,0 +1,309 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import {
+	type ExtensionAPI,
+	type ExtensionContext,
+	getMarkdownTheme,
+} from "@earendil-works/pi-coding-agent";
+import { Box, Markdown, Text } from "@earendil-works/pi-tui";
+import type { ActiveAgentSummary, CrewRuntime } from "./crew.js";
+
+export type SendMessageFn = ExtensionAPI["sendMessage"];
+type Message = Parameters<SendMessageFn>[0];
+
+type ToolTheme = Parameters<Exclude<Parameters<ExtensionAPI["registerTool"]>[0]["renderCall"], undefined>>[1];
+export type ToolResult = AgentToolResult<unknown>;
+
+export type SubagentStatus = "running" | "waiting" | "done" | "error" | "aborted";
+
+export const STATUS_ICON: Record<SubagentStatus, string> = {
+	running: "⏳",
+	waiting: "⏳",
+	done: "✅",
+	error: "❌",
+	aborted: "⏹️",
+};
+
+export const STATUS_LABEL: Record<SubagentStatus, string> = {
+	running: "running",
+	waiting: "waiting for response",
+	done: "done",
+	error: "failed",
+	aborted: "aborted",
+};
+
+export interface SteeringPayload {
+	id: string;
+	agentName: string;
+	sessionFile?: string;
+	status: SubagentStatus;
+	result?: string;
+	error?: string;
+}
+
+export interface CrewResultMessageDetails {
+	agentId: string;
+	agentName: string;
+	sessionFile?: string;
+	status: SubagentStatus;
+	body?: string;
+}
+
+export function getCrewResultTitle(details: {
+	agentId: string;
+	agentName: string;
+	status: SubagentStatus;
+}): string {
+	return `Subagent '${details.agentName}' (${details.agentId}) ${STATUS_LABEL[details.status]}`;
+}
+
+function sendWithDeliveryPolicy(
+	message: Message,
+	sendMessage: SendMessageFn,
+	opts: { isIdle: boolean; triggerTurn: boolean },
+): void {
+	sendMessage(
+		message,
+		opts.isIdle
+			? { triggerTurn: opts.triggerTurn }
+			: { deliverAs: "steer", triggerTurn: opts.triggerTurn },
+	);
+}
+
+function getSteeringBody(payload: SteeringPayload): string | undefined {
+	return (payload.status === "error" || payload.status === "aborted")
+		? (payload.error ?? payload.result)
+		: (payload.result ?? payload.error);
+}
+
+export function sendSteeringMessage(
+	payload: SteeringPayload,
+	sendMessage: SendMessageFn,
+	opts: { isIdle: boolean; triggerTurn: boolean },
+): void {
+	const body = getSteeringBody(payload);
+	const title = getCrewResultTitle({ agentId: payload.id, agentName: payload.agentName, status: payload.status });
+	const content = body
+		? `**${STATUS_ICON[payload.status]} ${title}**\n\n${body}`
+		: `**${STATUS_ICON[payload.status]} ${title}**`;
+
+	sendWithDeliveryPolicy(
+		{
+			customType: "crew-result",
+			content,
+			display: true,
+			details: {
+				agentId: payload.id,
+				agentName: payload.agentName,
+				sessionFile: payload.sessionFile,
+				status: payload.status,
+				body,
+			} satisfies CrewResultMessageDetails,
+		},
+		sendMessage,
+		opts,
+	);
+}
+
+export function sendRemainingNote(
+	remainingCount: number,
+	sendMessage: SendMessageFn,
+	opts: { isIdle: boolean; triggerTurn: boolean },
+): void {
+	if (remainingCount <= 0) return;
+	sendWithDeliveryPolicy(
+		{
+			customType: "crew-remaining",
+			content: `⏳ ${remainingCount} subagent(s) still running`,
+			display: true,
+		},
+		sendMessage,
+		opts,
+	);
+}
+
+export function sendCrewListActiveWarning(
+	sendMessage: SendMessageFn,
+	opts: { isIdle: boolean; triggerTurn: boolean },
+): void {
+	sendWithDeliveryPolicy(
+		{
+			customType: "crew-list-warning",
+			content:
+				"⚠ Active subagents detected. Do not poll crew_list for completion — results arrive as steering messages. Continue with unrelated work or end your turn and wait for the steering messages.",
+			display: true,
+		},
+		sendMessage,
+		opts,
+	);
+}
+
+function getStatusColor(status: CrewResultMessageDetails["status"]): "success" | "error" | "warning" | "muted" {
+	switch (status) {
+		case "done":
+			return "success";
+		case "error":
+		case "aborted":
+			return "error";
+		case "running":
+		case "waiting":
+			return "warning";
+		default:
+			return "muted";
+	}
+}
+
+type MessageRenderer = Parameters<ExtensionAPI["registerMessageRenderer"]>[1];
+type MessageRendererTheme = Parameters<MessageRenderer>[2];
+
+function renderWarningMessage(content: unknown, theme: MessageRendererTheme): Box {
+	const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
+	box.addChild(new Text(theme.fg("warning", String(content ?? "")), 0, 0));
+	return box;
+}
+
+export function registerCrewMessageRenderers(pi: ExtensionAPI): void {
+	pi.registerMessageRenderer("crew-result", (message, { expanded }, theme) => {
+		const details = message.details as CrewResultMessageDetails | undefined;
+		const title = details ? getCrewResultTitle(details) : "Subagent update";
+		const icon = details
+			? theme.fg(getStatusColor(details.status), STATUS_ICON[details.status])
+			: theme.fg("muted", "ℹ");
+		const header = `${icon} ${theme.fg("toolTitle", theme.bold(title))}`;
+		const body = details?.body ?? (!details && message.content ? String(message.content) : undefined);
+
+		const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
+		box.addChild(new Text(header, 0, 0));
+
+		if (details?.sessionFile) {
+			box.addChild(new Text(theme.fg("muted", `📁 ${details.sessionFile}`), 0, 0));
+		}
+
+		if (body) {
+			if (expanded) {
+				box.addChild(new Text("", 0, 0));
+				box.addChild(new Markdown(body, 0, 0, getMarkdownTheme()));
+			} else {
+				const lines = body.split("\n");
+				const preview = lines.slice(0, 5).join("\n");
+				box.addChild(new Text(theme.fg("dim", preview), 0, 0));
+				if (lines.length > 5) box.addChild(new Text(theme.fg("muted", "(Ctrl+O to expand)"), 0, 0));
+			}
+		}
+
+		return box;
+	});
+
+	pi.registerMessageRenderer("crew-remaining", (message, _options, theme) => renderWarningMessage(message.content, theme));
+	pi.registerMessageRenderer("crew-list-warning", (message, _options, theme) => renderWarningMessage(message.content, theme));
+}
+
+export function renderCrewCall(theme: ToolTheme, name: string, id: string, preview?: string): Box {
+	const box = new Box(1, 1);
+	box.addChild(new Text(theme.fg("toolTitle", theme.bold(`${name} `)) + theme.fg("accent", id), 0, 0));
+	if (preview) box.addChild(new Text(theme.fg("dim", preview), 0, 0));
+	return box;
+}
+
+export function renderCrewResult(result: ToolResult, theme: ToolTheme): Text {
+	const text = result.content[0];
+	const details = result.details as { error?: boolean } | undefined;
+	const content = text?.type === "text" && text.text ? text.text : "(no output)";
+	return new Text(details?.error ? theme.fg("error", content) : theme.fg("success", content), 0, 0);
+}
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const SPINNER_INTERVAL_MS = 80;
+
+function formatTokens(tokens: number): string {
+	if (tokens >= 1_000_000) return `${(tokens / 1_000_000).toFixed(1)}M`;
+	if (tokens >= 1_000) return `${(tokens / 1_000).toFixed(1)}k`;
+	return String(tokens);
+}
+
+function buildWidgetLine(agent: ActiveAgentSummary, frame: string): string {
+	const model = agent.model ?? "…";
+	const icon = agent.status === "waiting" ? "⏳" : frame;
+	return `${icon} ${agent.id} (${model}) · turn ${agent.turns} · ${formatTokens(agent.contextTokens)} ctx`;
+}
+
+interface WidgetState {
+	ctx: ExtensionContext;
+	text: Text;
+	// biome-ignore lint: TUI type from factory param
+	tui: any;
+	timer: ReturnType<typeof setInterval>;
+	frameIndex: number;
+}
+
+let widget: WidgetState | undefined;
+
+function disposeWidget(state: WidgetState): void {
+	clearInterval(state.timer);
+	if (widget === state) widget = undefined;
+}
+
+function clearWidget(): void {
+	const current = widget;
+	if (!current) return;
+	disposeWidget(current);
+	current.ctx.ui.setWidget("crew-status", undefined);
+}
+
+function hasRunningAgent(agents: ActiveAgentSummary[]): boolean {
+	return agents.some((agent) => agent.status === "running");
+}
+
+function syncWidgetText(state: WidgetState, agents: ActiveAgentSummary[]): void {
+	const frame = SPINNER_FRAMES[state.frameIndex % SPINNER_FRAMES.length];
+	state.text.setText(agents.map((agent) => buildWidgetLine(agent, frame)).join("\n"));
+	state.tui.requestRender();
+}
+
+export function updateWidget(ctx: ExtensionContext, crew: CrewRuntime): void {
+	if (!ctx.hasUI) {
+		clearWidget();
+		return;
+	}
+
+	const ownerSessionId = ctx.sessionManager.getSessionId();
+	const running = crew.getActiveSummariesForOwner(ownerSessionId);
+	if (running.length === 0) {
+		clearWidget();
+		return;
+	}
+
+	if (widget && widget.ctx !== ctx) clearWidget();
+	if (widget) {
+		syncWidgetText(widget, running);
+		return;
+	}
+
+	ctx.ui.setWidget("crew-status", (tui, _theme) => {
+		const text = new Text("", 1, 0);
+		const state: WidgetState = {
+			ctx,
+			text,
+			tui,
+			frameIndex: 0,
+			timer: setInterval(() => {
+				const agents = crew.getActiveSummariesForOwner(ownerSessionId);
+				if (agents.length === 0) {
+					clearWidget();
+					return;
+				}
+				if (!hasRunningAgent(agents)) return;
+				state.frameIndex++;
+				syncWidgetText(state, agents);
+			}, SPINNER_INTERVAL_MS),
+		};
+
+		widget = state;
+		syncWidgetText(state, running);
+
+		return Object.assign(text, {
+			dispose() {
+				disposeWidget(state);
+			},
+		});
+	});
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@melihmucuk/pi-crew",
-  "version": "1.0.17",
+  "version": "1.0.18",
   "type": "module",
   "description": "Non-blocking subagent orchestration for pi coding agent",
   "files": [