@melihmucuk/pi-crew 1.0.17 → 1.0.19

package/extension/ui.ts

@@ -0,0 +1,291 @@
+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 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-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.19",
   "type": "module",
   "description": "Non-blocking subagent orchestration for pi coding agent",
   "files": [
@@ -43,13 +43,13 @@
     "typebox": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-agent-core": "^0.75.4",
-    "@earendil-works/pi-ai": "^0.75.4",
-    "@earendil-works/pi-coding-agent": "^0.75.4",
-    "@earendil-works/pi-tui": "^0.75.4",
+    "@earendil-works/pi-agent-core": "^0.76.0",
+    "@earendil-works/pi-ai": "^0.76.0",
+    "@earendil-works/pi-coding-agent": "^0.76.0",
+    "@earendil-works/pi-tui": "^0.76.0",
     "@types/node": "^22.19.17",
     "tsx": "^4.22.3",
-    "typebox": "^1.1.38",
+    "typebox": "^1.1.39",
     "typescript": "^5.9.3"
   }
 }

package/prompts/pi-crew-review.md

@@ -10,7 +10,7 @@ You are a review orchestrator, not a reviewer. Resolve the review scope, gather
 
 ## Scope
 
-Use the user's scope when provided. Otherwise rely on each reviewer’s default scope. If “latest” or “recent” is requested, review the last 5 commits unless a count is given.
+Use the user's scope when provided. Otherwise rely on each reviewer’s default scope. If “latest” or “recent” is requested, review the last 5 commits unless a count is given. If “full”, “codebase”, or whole-repo review is requested, treat it as an explicit non-default scope and pass that scope to reviewers.
 
 Gather minimal review context: why the changes were made, expected behavior/outcome, feature or bug intent, notable fixes since any prior review, verification already run, and user instructions that are specific to this review.
 
@@ -33,6 +33,8 @@ If you include a Goal, make it specific to the change intent, not the reviewer r
 
 For default reviews, do not include a Scope section or mention uncommitted/current repo changes in the subagent brief unless needed to disambiguate scope. If you need to state task-specific emphasis, use `Review focus:` instead of `Scope:`.
 
+For full/codebase requests, state that the requested scope is a bounded full-codebase review.
+
 Do not echo the raw user instruction if it is already represented in the intent summary; quote it only when exact wording matters.
 
 Do not restate reviewer-role boilerplate implied by the selected reviewer, such as telling `code-reviewer` to find actionable bugs or telling `quality-reviewer` to review maintainability. Do not include default scope, generic non-goals, acceptance criteria, output format, edit permissions, or severity rules unless the user explicitly overrides them.
@@ -49,26 +51,33 @@ You may do a minimal spot-check only when a finding is ambiguous, high-impact, o
 
 Reply in the user's language. Apply the gate before merging.
 
+For each accepted finding, preserve enough detail to act without reading subagent logs:
+
+**[SEVERITY] Category: Title**
+Source: `code-reviewer` | `quality-reviewer` | `both`
+File: `path:line`
+Issue: what is wrong
+Evidence: what was verified
+Impact: concrete consequence
+Fix: specific suggested correction
+
+Do not forward findings as summaries only. If evidence, location, or fix is missing and cannot be inferred from the reviewer result, omit the finding or report it as insufficiently evidenced.
+
 Sections:
 
-### Consensus Findings
-Issues clearly reported by both reviewers.
+### Findings
+List all accepted findings in severity order. Use `Source:` to identify `code-reviewer`, `quality-reviewer`, or `both`.
 
-### Code Review Findings
-Accepted findings only from `code-reviewer`.
+If both reviewers report no accepted findings, write only:
 
-### Quality Review Findings
-Accepted findings only from `quality-reviewer`.
+No accepted findings.
 
-### Final Summary
-- Review scope
-- Reviewers run and any failures
-- Consensus findings count
-- Code review findings count
-- Quality review findings count
-- Overall assessment
+### Summary
+- Scope: [review scope]
+- Reviewers: [completed reviewers and any failures]
+- Findings: [count by severity]
+- Result: [one-sentence overall assessment]
 
 Rules:
 - Do not repeat overlapping findings.
-- Do not present a single-reviewer finding as consensus.
-- If both reviewers report no accepted findings, say so clearly.
+- Mark a finding as `Source: both` only when both reviewers clearly reported the same issue.

package/skills/pi-crew/SKILL.md

@@ -35,6 +35,8 @@ Omit sections that would only restate the selected subagent’s role, default sc
 
 Include only information that helps this specific subagent do this specific task: intent, expected outcome, relevant decisions, exact errors/output, unusual constraints, and file paths or entry points that genuinely clarify the task. Use short Markdown sections and bullets when they improve scanability, especially for multi-part intent, constraints, observations, requirements, or acceptance criteria; avoid dense paragraphs.
 
+For repeated workflows, make each spawn brief independent. Do not assume a new subagent knows earlier loop results, owner-session discussion, or what another subagent saw. If prior findings, fixes, decisions, or verification matter, summarize the concrete facts or point to durable artifacts the subagent can inspect. Avoid vague references like “we fixed the first review findings” unless you also state what those findings/fixes were or define the current review target without relying on that history.
+
 Do not restate boilerplate implied by the selected subagent’s role, name, or description. Avoid repeating default scope, output format, edit permissions, or repo guidance. Subagents run in the same cwd as the orchestrator, so do not include mechanical Git state they can inspect themselves, such as full changed-file lists, staged/unstaged/untracked inventories, branch/cwd details, or generic project constraints, unless those details define a non-default scope or prevent ambiguity.
 
 If the user points to a plan, spec, issue, design, or doc as task intent, read it when practical and summarize the relevant intent instead of merely passing the path. Prefer explaining why the work matters and what outcome is expected over restating repository state.
@@ -44,7 +46,7 @@ If the user points to a plan, spec, issue, design, or doc as task intent, read i
 - Wait for subagent results before using them. Never invent or predict results.
 - Evaluate each result against the task acceptance criteria.
 - If results conflict, are incomplete, or miss criteria, state that clearly and use a follow-up or new spawn only when needed.
-- After spawning, continue only with unrelated work or end the turn.
+- After spawning, do not work on the delegated task; wait for results, continue only with unrelated work, or end the turn.
 
 ## Interactive Subagents