pi-crew 0.9.27 → 0.9.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-crew",
-  "version": "0.9.27",
+  "version": "0.9.28",
   "description": "Pi extension for coordinated AI teams, workflows, worktrees, and async task orchestration",
   "author": "baphuongna",
   "license": "MIT",

package/src/agents/agent-config.ts

@@ -83,6 +83,8 @@ export interface AgentConfig {
 	contextMode?: "fresh" | "fork";
 	/** Maximum turns for this agent. Overrides runtime config if set. */
 	maxTurns?: number;
+	/** Cap on output tokens per API call. Set via PI_CREW_MAX_OUTPUT_TOKENS env in child. */
+	maxTokens?: number;
 	/** Effort level for this agent. Controls how much work the agent puts in. */
 	effort?: "low" | "medium" | "high";
 	/** Tools to explicitly forbid for this agent. Takes precedence over allowedTools. */

package/src/agents/discover-agents.ts

@@ -431,6 +431,10 @@ function parseAgentFile(filePath: string, source: ResourceSource): AgentConfig |
 				const n = Number.parseInt(frontmatter.maxTurns, 10);
 				return Number.isFinite(n) && n > 0 ? n : undefined;
 			})(),
+			maxTokens: (() => {
+				const n = Number.parseInt(frontmatter.maxTokens, 10);
+				return Number.isFinite(n) && n > 0 ? n : undefined;
+			})(),
 			effort:
 				frontmatter.effort === "low" || frontmatter.effort === "medium" || frontmatter.effort === "high"
 					? frontmatter.effort

package/src/extension/crew-vibes/figures.ts

@@ -61,7 +61,7 @@ const PUA_CREW_FRAMES: readonly string[] = [
  * - `"pua"`: runner-pose glyphs from crew-vibes.ttf, requires font install
  */
 export function crewFrames(style: "braille" | "pua" = "pua"): readonly string[] {
-	// Web terminals (gotty, wetty) cannot render PUA glyphs — use braille.
+	// Web terminals (gotty, wetty) cannot render PUA glyphs — fall back to braille
 	if (style === "pua" && isWebTerminal()) return BRAILLE_FRAMES;
 	return style === "pua" ? PUA_CREW_FRAMES : BRAILLE_FRAMES;
 }

package/src/extension/crew-vibes/index.ts

@@ -1,7 +1,6 @@
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { type CrewVibesConfig, loadConfig, PROVIDER_STATUS_ID, saveConfig } from "./config.ts";
-import { isWebTerminal } from "./font-detect.ts";
-import { fetchProviderUsage, clearProviderUsageCache } from "./provider-usage.ts";
+import { fetchProviderUsage, clearProviderUsageCache, providerSupportsQuota } from "./provider-usage.ts";
 import { intervalForSpeed } from "./figures.ts";
 import {
 	asCrewTheme,
@@ -18,7 +17,6 @@ import {
 	setSpeedStatus,
 } from "./render.ts";
 import { SpeedAnimator, SpeedTracker } from "./speed.ts";
-import { CAT_FRAMES } from "./cat-frames.ts";
 
 export const CREW_VIBES_STATUS_KEY = "pi-crew-vibes";
 
@@ -52,7 +50,7 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 	let capacityTimer: ReturnType<typeof setInterval> | undefined;
 	let providerTimer: ReturnType<typeof setInterval> | undefined;
 	let lastProviderText: string | undefined;
-	let catFrameIndex = 0;
+	let currentProvider: string | undefined;
 
 	/** Strip ANSI codes to measure visible width. */
 	function visibleLen(text: string): number {
@@ -146,11 +144,6 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 			const speed = speedTracker.liveTokS();
 			applyIndicator(ctx, speed);
 			renderWorking(ctx, speed);
-			// Update cat animation frame in web terminals
-			if (isWebTerminal()) {
-				catFrameIndex = (catFrameIndex + 1) % CAT_FRAMES.length;
-				ctx.ui.setWidget("crew-vibes-cat", [...CAT_FRAMES[catFrameIndex]], { placement: "aboveEditor" });
-			}
 		}, config.speed.renderIntervalMs);
 		liveTimer.unref?.();
 	}
@@ -186,7 +179,7 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 				return;
 			}
 			try {
-				const usage = await fetchProviderUsage(config.capacity.providerRefreshMs);
+				const usage = await fetchProviderUsage(config.capacity.providerRefreshMs, currentProvider);
 				lastProviderText = renderProviderUsage(themeOf(ctx), usage);
 				// Re-render combined capacity + provider line
 				publishCapacity(ctx);
@@ -235,6 +228,8 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 		speedTracker.resetSession();
 		footerAnimator.reset(null);
 		clearProviderUsageCache();
+		// Initialize provider from current model — model_select only fires on manual switch
+		currentProvider = (ctx.model as { provider?: string } | undefined)?.provider;
 		if (!config.enabled) {
 			clearVibesStatus(ctx);
 			return;
@@ -266,10 +261,6 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 		footerAnimator.reset(speedTracker.lastTokS);
 		startLiveTimer(ctx);
 		lastRenderedAt = 0;
-		// Show cat widget in web terminals
-		if (isWebTerminal() && ctx.hasUI) {
-			ctx.ui.setWidget("crew-vibes-cat", [...CAT_FRAMES[0]], { placement: "aboveEditor" });
-		}
 	});
 
 	pi.on("message_update", (event, ctx) => {
@@ -304,10 +295,6 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 		publishSpeedFooter(ctx);
 		startFooterTimer(ctx);
 		applyIndicator(ctx, speedTracker.lastTokS);
-		// Remove cat widget on message end
-		if (isWebTerminal() && ctx.hasUI) {
-			ctx.ui.setWidget("crew-vibes-cat", undefined);
-		}
 	});
 
 	pi.on("turn_end", () => {
@@ -321,11 +308,14 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 		if (ctx && config.enabled && ctx.hasUI) {
 			applyIndicator(ctx, speedTracker.lastTokS);
 			ctx.ui.setWorkingMessage();
-			if (isWebTerminal()) ctx.ui.setWidget("crew-vibes-cat", undefined);
 		}
 	});
 
-	pi.on("model_select", (_event, ctx) => publishCapacity(ctx));
+	pi.on("model_select", (event, ctx) => {
+		currentProvider = (event as { model?: { provider?: string } }).model?.provider;
+		clearProviderUsageCache();
+		publishCapacity(ctx);
+	});
 	pi.on("session_compact", (_event, ctx) => publishCapacity(ctx));
 	pi.on("session_tree", (_event, ctx) => publishCapacity(ctx));
 
@@ -335,7 +325,6 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 		stopCapacityTimer();
 		stopProviderTimer();
 		clearVibesStatus(ctx);
-		if (ctx.hasUI) ctx.ui.setWidget("crew-vibes-cat", undefined);
 	});
 
 	async function handleCommand(args: string, ctx: ExtensionCommandContext): Promise<void> {

package/src/extension/crew-vibes/provider-usage.ts

@@ -68,6 +68,21 @@ export function loadZaiToken(): string | undefined {
 	}
 }
 
+/** Load the Minimax API key from env or auth.json. */
+export function loadMinimaxToken(): string | undefined {
+	const envKey = process.env.MINIMAX_API_KEY?.trim();
+	if (envKey) return envKey;
+	try {
+		const data = JSON.parse(readFileSync(piAuthPath(), "utf8")) as {
+			minimax?: { key?: string };
+		};
+		const key = data.minimax?.key;
+		return typeof key === "string" && key.length > 0 ? key : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
 /** Copilot host entry keys used by the legacy GitHub Copilot CLI. */
 type CopilotHostEntry = {
 	oauth_token?: string;
@@ -262,69 +277,120 @@ export function clearProviderUsageCache(): void {
 	cachedAt = 0;
 }
 
+/** Minimax token plan remains response shape. */
+type MinimaxModelRemain = {
+	model_name?: string;
+	current_interval_remaining_percent?: number;
+	current_weekly_remaining_percent?: number;
+	end_time?: number;
+	weekly_end_time?: number;
+};
+type MinimaxUsageResponse = {
+	model_remains?: MinimaxModelRemain[];
+	base_resp?: { status_code?: number; status_msg?: string };
+};
+
+async function fetchMinimaxUsage(token: string): Promise<ProviderUsage> {
+	const data = await withTimeout(10000, async (signal) => {
+		const res = await fetch("https://www.minimax.io/v1/token_plan/remains", {
+			headers: { Authorization: `Bearer ${token}`, Accept: "application/json" },
+			signal,
+		});
+		if (!res.ok) throw new Error(`minimax usage HTTP ${res.status}`);
+		return (await res.json()) as MinimaxUsageResponse;
+	});
+	if (data.base_resp?.status_code !== 0) throw new Error(data.base_resp?.status_msg || "minimax API error");
+
+	// Find the "general" model (text/chat). Fall back to first model.
+	const models = data.model_remains ?? [];
+	const general = models.find((m) => m.model_name === "general") ?? models[0];
+	if (!general) throw new Error("minimax: no model data");
+
+	// remaining_percent → used percent
+	const intervalUsed = 100 - (general.current_interval_remaining_percent ?? 100);
+	const weeklyUsed = 100 - (general.current_weekly_remaining_percent ?? 100);
+
+	const intervalReset = typeof general.end_time === "number" ? new Date(general.end_time).toISOString() : null;
+	const weeklyReset = typeof general.weekly_end_time === "number" ? new Date(general.weekly_end_time).toISOString() : null;
+
+	return {
+		providerName: "Minimax",
+		fiveHourPercent: intervalUsed,
+		fiveHourResetAt: intervalReset,
+		weeklyPercent: weeklyUsed,
+		weeklyResetAt: weeklyReset,
+	};
+}
+
+/** Providers that have a quota API. */
+const QUOTA_PROVIDERS = new Set(["anthropic", "minimax", "minimax-cn", "zai", "github-copilot"]);
+
+/** Check if a provider supports quota checking. */
+export function providerSupportsQuota(provider: string): boolean {
+	return QUOTA_PROVIDERS.has(provider);
+}
+
+/** Fetch usage for a SPECIFIC provider. Returns null if not supported. */
+async function fetchForProvider(provider: string): Promise<ProviderUsage | null> {
+	switch (provider) {
+		case "anthropic": {
+			const token = loadAnthropicToken();
+			if (!token) return null;
+			const base = await fetchAnthropicUsage(token);
+			return { providerName: "Claude", ...base };
+		}
+		case "minimax":
+		case "minimax-cn": {
+			const token = loadMinimaxToken();
+			if (!token) return null;
+			return await fetchMinimaxUsage(token);
+		}
+		case "zai": {
+			const token = loadZaiToken();
+			if (!token) return null;
+			const usage = await fetchZaiUsage(token);
+			usage.providerName = "z.ai";
+			return usage;
+		}
+		case "github-copilot": {
+			const token = loadCopilotToken();
+			if (!token) return null;
+			const pct = await fetchCopilotMonthlyPercent(token);
+			if (pct === undefined) return null;
+			return {
+				providerName: "Copilot",
+				fiveHourPercent: 0,
+				fiveHourResetAt: null,
+				weeklyPercent: pct,
+				weeklyResetAt: null,
+				copilotMonthlyPercent: pct,
+			};
+		}
+		default:
+			return null;
+	}
+}
+
 /**
- * Fetch provider rate-limit usage, caching the result for `maxAgeMs`.
- *
- * Tries providers in order: Anthropic → z.ai → Copilot.
- * Returns the first one that has credentials + responds successfully.
- * Returns `null` when no credentials exist or all fetches fail — never throws.
+ * Fetch provider rate-limit usage for the current model's provider.
+ * Returns `null` when provider has no quota API or no credentials.
  */
-export async function fetchProviderUsage(maxAgeMs = 300000): Promise<ProviderUsage | null> {
-	// Serve fresh-enough cache without hitting the network.
+export async function fetchProviderUsage(maxAgeMs = 300000, provider?: string): Promise<ProviderUsage | null> {
+	if (!provider || !QUOTA_PROVIDERS.has(provider)) {
+		cachedUsage = null;
+		return null;
+	}
 	if (cachedUsage !== null && Date.now() - cachedAt < maxAgeMs) {
 		return cachedUsage;
 	}
-
 	try {
-		// Try Anthropic first
-		const anthropicToken = loadAnthropicToken();
-		if (anthropicToken) {
-			const base = await fetchAnthropicUsage(anthropicToken);
-			const usage: ProviderUsage = {
-				providerName: "Claude",
-				fiveHourPercent: base.fiveHourPercent,
-				fiveHourResetAt: base.fiveHourResetAt,
-				weeklyPercent: base.weeklyPercent,
-				weeklyResetAt: base.weeklyResetAt,
-			};
+		const usage = await fetchForProvider(provider);
+		if (usage) {
 			cachedUsage = usage;
 			cachedAt = Date.now();
-			return usage;
 		}
-
-		// Try z.ai
-		const zaiToken = loadZaiToken();
-		if (zaiToken) {
-			const usage = await fetchZaiUsage(zaiToken);
-			usage.providerName = "z.ai";
-			cachedUsage = usage;
-			cachedAt = Date.now();
-			return usage;
-		}
-
-		// Try Copilot
-		const copilotToken = loadCopilotToken();
-		if (copilotToken) {
-			const monthlyPercent = await fetchCopilotMonthlyPercent(copilotToken);
-			if (monthlyPercent !== undefined) {
-				const usage: ProviderUsage = {
-					providerName: "Copilot",
-					fiveHourPercent: 0,
-					fiveHourResetAt: null,
-					weeklyPercent: monthlyPercent,
-					weeklyResetAt: null,
-					copilotMonthlyPercent: monthlyPercent,
-				};
-				cachedUsage = usage;
-				cachedAt = Date.now();
-				return usage;
-			}
-		}
-
-		// No credentials for any provider
-		return null;
+		return usage;
 	} catch {
-		// Network error / timeout / parse error — fail gracefully.
 		return null;
 	}
 }

package/src/extension/team-tool.ts

@@ -498,6 +498,17 @@ export function handleSteer(params: TeamToolParamsValue, ctx: TeamContext): PiTe
 	}
 	task.pendingSteers.push(message);
 	saveRunTasks(loaded.manifest, loaded.tasks);
+	// Real-time steer delivery: write to steering file so child can read immediately
+	try {
+		const steeringDir = `${loaded.manifest.artifactsRoot}/steering`;
+		fs.mkdirSync(steeringDir, { recursive: true });
+		fs.appendFileSync(
+			`${steeringDir}/${taskId}.jsonl`,
+			JSON.stringify({ type: "steer", message, ts: new Date().toISOString() }) + "\n",
+		);
+	} catch {
+		// Best-effort: file write failure doesn't block the steer from pending array
+	}
 	appendEvent(loaded.manifest.eventsPath, {
 		type: "task.steer_queued",
 		runId,

package/src/prompt/prompt-runtime.ts

@@ -1,9 +1,12 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import * as fs from "node:fs";
 
 export const PI_TEAMS_INHERIT_PROJECT_CONTEXT_ENV = "PI_TEAMS_INHERIT_PROJECT_CONTEXT";
 export const PI_TEAMS_INHERIT_SKILLS_ENV = "PI_TEAMS_INHERIT_SKILLS";
 export const PI_CREW_INHERIT_PROJECT_CONTEXT_ENV = "PI_CREW_INHERIT_PROJECT_CONTEXT";
 export const PI_CREW_INHERIT_SKILLS_ENV = "PI_CREW_INHERIT_SKILLS";
+const PI_CREW_MAX_OUTPUT_ENV = "PI_CREW_MAX_OUTPUT";
+const PI_CREW_STEERING_FILE_ENV = "PI_CREW_STEERING_FILE";
 
 const PROJECT_CONTEXT_HEADER = "\n\n# Project Context\n\nProject-specific instructions and guidelines:\n\n";
 const SKILLS_HEADER = "\n\nThe following skills provide specialized instructions for specific tasks.";
@@ -58,6 +61,68 @@ export function rewriteTeamWorkerPrompt(prompt: string, options: { inheritProjec
 }
 
 export default function registerPiTeamsPromptRuntime(pi: ExtensionAPI): void {
+	// ── Feature 1: maxTokens cap ──────────────────────────────────────────
+	// Cap output tokens per API call for background workers. Reads
+	// PI_CREW_MAX_OUTPUT_TOKENS env (set by pi-args.ts from agent.maxTokens).
+	const maxTokensEnv = process.env[PI_CREW_MAX_OUTPUT_ENV];
+	const maxTokensCap = maxTokensEnv ? Number.parseInt(maxTokensEnv, 10) : undefined;
+	if (maxTokensCap && maxTokensCap > 0) {
+		pi.on("before_provider_request", (event) => {
+			const payload = event.payload as Record<string, unknown> | undefined;
+			if (!payload || typeof payload !== "object") return;
+			// Cap both OpenAI-style max_tokens and Anthropic-style max_tokens
+			if (typeof payload.max_tokens === "number" && payload.max_tokens > maxTokensCap) {
+				payload.max_tokens = maxTokensCap;
+			}
+		});
+	}
+
+	// ── Feature 2: real-time steering ──────────────────────────────────────
+	// Poll the steering JSONL file for new steer messages. The parent (team
+	// tool) writes steers here in real-time; this reader injects them into
+	// the active session via pi.sendMessage with deliverAs:"steer".
+	const steeringFile = process.env[PI_CREW_STEERING_FILE_ENV];
+	if (steeringFile) {
+		let lastOffset = 0;
+		const pollSteering = (): void => {
+			try {
+				const stat = fs.statSync(steeringFile, { throwIfNoEntry: false });
+				if (!stat || stat.size <= lastOffset) return;
+				const fd = fs.openSync(steeringFile, "r");
+				try {
+					const buf = Buffer.alloc(stat.size - lastOffset);
+					fs.readSync(fd, buf, 0, buf.length, lastOffset);
+					lastOffset = stat.size;
+					const lines = buf.toString("utf8").split("\n").filter(Boolean);
+					for (const line of lines) {
+						try {
+							const entry = JSON.parse(line) as { type?: string; message?: string };
+							if (entry.type === "steer" && entry.message) {
+								pi.sendMessage(
+									{ customType: "crew-steer", content: entry.message, display: false },
+									{ deliverAs: "steer" },
+								);
+							}
+						} catch {
+							// Malformed line — skip
+						}
+					}
+				} finally {
+					try {
+						fs.closeSync(fd);
+					} catch {
+						/* already closed */
+					}
+				}
+			} catch {
+				// File doesn't exist yet or read error — will retry next tick
+			}
+		};
+		const timer = setInterval(pollSteering, 500);
+		timer.unref?.();
+	}
+
+	// ── Prompt rewriting (existing) ────────────────────────────────────────
 	pi.on("before_agent_start", (event) => {
 		const inheritProjectContext = readBooleanEnvAny(PI_CREW_INHERIT_PROJECT_CONTEXT_ENV, PI_TEAMS_INHERIT_PROJECT_CONTEXT_ENV);
 		const inheritSkills = readBooleanEnvAny(PI_CREW_INHERIT_SKILLS_ENV, PI_TEAMS_INHERIT_SKILLS_ENV);

package/src/runtime/child-pi.ts

@@ -238,6 +238,8 @@ export interface ChildPiRunInput {
 	excludeContextBash?: boolean;
 	/** pi session ID for session naming (aligns with pi-crew run ID) */
 	sessionId?: string;
+	/** Path to steering JSONL file for real-time steer injection. */
+	steeringFile?: string;
 	/** Run ID for cleanup tracking */
 	runId?: string;
 	/** Agent ID for cleanup tracking */
@@ -317,6 +319,8 @@ const BASE_ALLOWLIST: string[] = [
 	"PI_TEAMS_PI_BIN",
 	"PI_TEAMS_MOCK_CHILD_PI",
 	"PI_CREW_ALLOW_MOCK",
+	"PI_CREW_MAX_OUTPUT",
+	"PI_CREW_STEERING_FILE",
 ];
 
 export function buildChildPiSpawnOptions(cwd: string, env: NodeJS.ProcessEnv, model?: string): SpawnOptions {
@@ -888,6 +892,8 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 		skillPaths: input.skillPaths,
 		role: input.role,
 	});
+	// Pass steering file path to child for real-time steer injection
+	if (input.steeringFile) built.env.PI_CREW_STEERING_FILE = input.steeringFile;
 	const spawnSpec = getPiSpawnCommand(built.args);
 	try {
 		return await new Promise<ChildPiRunResult>((resolve) => {

package/src/runtime/pi-args.ts

@@ -360,6 +360,8 @@ export function buildPiWorkerArgs(input: BuildPiWorkerArgsInput): BuildPiWorkerA
 			PI_TEAMS_DEPTH: String(parentDepth + 1),
 			PI_TEAMS_MAX_DEPTH: String(maxDepth),
 			PI_TEAMS_ROLE: input.agent.name,
+			// maxTokens cap for background workers — prompt-runtime reads this to cap API output
+			...(input.agent.maxTokens ? { PI_CREW_MAX_OUTPUT: String(input.agent.maxTokens) } : {}),
 		},
 		tempDir,
 	};

package/src/runtime/task-runner.ts

@@ -449,6 +449,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 					runId: manifest.runId,
 					agentId: task.id,
 					artifactsRoot: manifest.artifactsRoot,
+					steeringFile: `${manifest.artifactsRoot}/steering/${task.id}.jsonl`,
 					onSpawn: (pid) => {
 						try {
 							({ task, tasks } = checkpointTask(manifest, tasks, task, "child-spawned", pid));