pi-crew 0.9.42 → 0.9.44

package/package.json

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

package/scripts/build-bundle.mjs

@@ -55,7 +55,8 @@ const result = await build({
 		"cli-highlight",
 		"diff",
 		"jiti",
-		"typebox",
+		"@sinclair/typebox",
+		"acorn",
 	],
 	// All node:* and Node-builtin modules are external by default for
 	// platform=node, but list explicitly for clarity.

package/src/agents/agent-config.ts

@@ -83,7 +83,7 @@ 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. */
+	/** Cap on output tokens per API call. Set via PI_CREW_MAX_OUTPUT env in child. */
 	maxTokens?: number;
 	/** Effort level for this agent. Controls how much work the agent puts in. */
 	effort?: "low" | "medium" | "high";

package/src/config/config.ts

@@ -169,7 +169,7 @@ export function invalidateConfigCache(): void {
 }
 
 function resolveHomeDir(): string {
-	const envValue = process.env.PI_TEAMS_HOME?.trim();
+	const envValue = (process.env.PI_TEAMS_HOME ?? process.env.PI_CREW_HOME)?.trim();
 	const defaultHome = os.homedir();
 	if (!envValue) return defaultHome;
 	// FIX (Round 14): When PI_TEAMS_HOME is explicitly set, validate that

package/src/config/types.ts

@@ -15,8 +15,6 @@ export interface PiTeamsAutonomousConfig {
 	preferAsyncForLongTasks?: boolean;
 	allowWorktreeSuggestion?: boolean;
 	magicKeywords?: Record<string, string[]>;
-	/** Mark certain bash commands as excludeFromContext to reduce context tokens. Default: false */
-	excludeContextBash?: boolean;
 }
 
 export interface CrewLimitsConfig {

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

@@ -13,7 +13,7 @@ export const CAPACITY_STATUS_ID = "pi-crew-bar";
 export const PROVIDER_STATUS_ID = "pi-crew-bar";
 
 function resolveHome(): string {
-	return process.env.PI_TEAMS_HOME?.trim() || process.env.HOME || process.env.USERPROFILE || "";
+	return (process.env.PI_TEAMS_HOME ?? process.env.PI_CREW_HOME)?.trim() || process.env.HOME || process.env.USERPROFILE || "";
 }
 
 export function configPath(): string {

package/src/extension/crew-vibes/font-detect.ts

@@ -33,18 +33,30 @@ export function hasCrewFontFile(): boolean {
 	return _hasFontFile;
 }
 
+let _isWebTerminal: boolean | null = null;
+
 /** Returns true when running in a web-based terminal (gotty, wetty, etc.)
  * where system fonts are not available for PUA rendering. */
 export function isWebTerminal(): boolean {
-	if (process.env.GOTTY || process.env.WEBTERM) return true;
-	if (process.env.TERM === "dumb") return true;
+	if (_isWebTerminal !== null) return _isWebTerminal;
+	if (process.env.GOTTY || process.env.WEBTERM) {
+		_isWebTerminal = true;
+		return true;
+	}
+	if (process.env.TERM === "dumb") {
+		_isWebTerminal = true;
+		return true;
+	}
 	try {
 		// Check current process and ancestors — gotty is often the grandparent
 		// (gotty → tmux → pi), so /proc/self/cgroup may not contain it.
 		let pid = process.pid;
 		for (let i = 0; i < 6 && pid > 1; i++) {
 			const cgroup = readFileSync(`/proc/${pid}/cgroup`, "utf8");
-			if (cgroup.includes("gotty") || cgroup.includes("wetty")) return true;
+			if (cgroup.includes("gotty") || cgroup.includes("wetty")) {
+				_isWebTerminal = true;
+				return true;
+			}
 			const match = cgroup.match(/\d+:.*:(.*)/);
 			// Read PPid from status
 			const status = readFileSync(`/proc/${pid}/status`, "utf8");
@@ -54,5 +66,6 @@ export function isWebTerminal(): boolean {
 	} catch {
 		// not Linux or /proc not available
 	}
+	_isWebTerminal = false;
 	return false;
 }

package/src/extension/cross-extension-rpc.ts

@@ -282,10 +282,14 @@ export function registerPiCrewRpc(
 				}
 			}, "pi-crew:rpc:status"),
 		),
-		on(events, "pi-crew:live-control", (raw) => {
-			const request = parseLiveControlRealtimeMessage(raw);
-			if (request) publishLiveControlRealtime(request);
-		}),
+		on(
+			events,
+			"pi-crew:live-control",
+			withHmacVerification((raw) => {
+				const request = parseLiveControlRealtimeMessage(raw);
+				if (request) publishLiveControlRealtime(request);
+			}, "pi-crew:live-control"),
+		),
 		on(
 			events,
 			"pi-crew:rpc:live-control",

package/src/extension/registration/commands.ts

@@ -1114,7 +1114,11 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 			const useProject = tokens.includes("--project");
 			const varEntries = tokens
 				.filter((t) => t.startsWith("--var=") || t.startsWith("--var "))
-				.map((t) => t.replace(/^--var(?:\s+|=)/, "").split("=", 2) as [string, string]);
+				.map((t): [string, string] => {
+					const s = t.replace(/^--var(?:\s+|=)/, "");
+					const idx = s.indexOf("=");
+					return idx === -1 ? [s, ""] : [s.slice(0, idx), s.slice(idx + 1)];
+				});
 			const templateId = tokens.find((t) => !t.startsWith("--") && !t.includes("="));
 			if (!templateId) {
 				await notifyCommandResult(

package/src/extension/registration/foreground-run-controller.ts

@@ -165,6 +165,7 @@ function startForegroundRunImpl(
 						goal: loaded?.manifest.goal,
 						status,
 						taskCount: loaded?.tasks.length,
+						durationMs: loaded?.manifest.createdAt ? Date.now() - new Date(loaded.manifest.createdAt).getTime() : 0,
 						timestamp: Date.now(),
 					});
 					const eventType =
@@ -183,6 +184,33 @@ function startForegroundRunImpl(
 							status,
 							taskCount: loaded?.tasks.length,
 							goal: loaded?.manifest.goal,
+							durationMs: loaded?.manifest.createdAt ? Date.now() - new Date(loaded.manifest.createdAt).getTime() : 0,
+						});
+					}
+
+					// Emit per-task events so task-level metrics (crew.task.count,
+					// crew.task.duration_ms, crew.task.tokens_total) record actual values.
+					const terminalTaskStatuses = new Set(["completed", "failed", "needs_attention"]);
+					for (const task of loaded?.tasks ?? []) {
+						if (!terminalTaskStatuses.has(task.status)) continue;
+						const taskEventType =
+							task.status === "completed"
+								? "crew.task.completed"
+								: task.status === "failed"
+									? "crew.task.failed"
+									: "crew.task.needs_attention";
+						pi.events?.emit?.(taskEventType, {
+							runId,
+							team: loaded?.manifest.team,
+							workflow: loaded?.manifest.workflow,
+							taskId: task.id,
+							taskCount: loaded?.tasks.length,
+							role: task.role,
+							durationMs:
+								task.startedAt && task.finishedAt
+									? new Date(task.finishedAt).getTime() - new Date(task.startedAt).getTime()
+									: 0,
+							tokens: (task.usage?.input ?? 0) + (task.usage?.output ?? 0),
 						});
 					}
 				}

package/src/extension/team-tool.ts

@@ -8,6 +8,7 @@ import { loadConfig, updateAutonomousConfig, updateConfig } from "../config/conf
 import type { executeTeamRun as _executeTeamRunFn } from "../runtime/team-runner.ts";
 import type { TeamToolParamsValue } from "../schema/team-tool-schema.ts";
 import { writeArtifact } from "../state/artifact-store.ts";
+import { TEAM_TERMINAL_TASK_STATUSES } from "../state/contracts.ts";
 import { appendEvent, appendEventFireAndForget } from "../state/event-log.ts";
 import { withRunLock } from "../state/locks.ts";
 import { replayPendingMailboxMessages } from "../state/mailbox.ts";
@@ -501,6 +502,10 @@ export function handleSteer(params: TeamToolParamsValue, ctx: TeamContext): PiTe
 	const task = loaded.tasks.find((t) => t.id === taskId);
 	if (!task) return result(`Task '${taskId}' not found`, { action: "steer", status: "error" }, true);
 	if (!task.pendingSteers) task.pendingSteers = [];
+	// T-S1: do not allow steering a task that has already reached a terminal status.
+	if (TEAM_TERMINAL_TASK_STATUSES.has(task.status)) {
+		return result(`Task '${taskId}' is ${task.status}; cannot steer.`, { action: "steer", status: "error" }, true);
+	}
 	// HIGH-04: Cap pendingSteers array to prevent unbounded memory growth
 	const MAX_PENDING_STEERS = 100;
 	if (task.pendingSteers.length >= MAX_PENDING_STEERS) {

package/src/prompt/prompt-runtime.ts

@@ -170,6 +170,21 @@ export default function registerPiTeamsPromptRuntime(pi: ExtensionAPI): void {
 			if (typeof payload.max_tokens === "number" && payload.max_tokens > maxTokensCap) {
 				payload.max_tokens = maxTokensCap;
 			}
+			// Also cap newer field names used by some providers
+			if (typeof payload.max_completion_tokens === "number" && payload.max_completion_tokens > maxTokensCap) {
+				payload.max_completion_tokens = maxTokensCap;
+			}
+			if (typeof payload.max_output_tokens === "number" && payload.max_output_tokens > maxTokensCap) {
+				payload.max_output_tokens = maxTokensCap;
+			}
+			const generationConfig = payload.generationConfig as Record<string, unknown> | undefined;
+			if (
+				generationConfig &&
+				typeof generationConfig.max_output_tokens === "number" &&
+				generationConfig.max_output_tokens > maxTokensCap
+			) {
+				generationConfig.max_output_tokens = maxTokensCap;
+			}
 		});
 	}
 

package/src/runtime/child-pi-constants.ts

@@ -0,0 +1,42 @@
+/**
+ * child-pi-constants.ts — Shared timing and capture constants for child-pi runtime.
+ *
+ * Extracted from child-pi.ts (H-7 decomposition, step 3). Zero behavior change.
+ *
+ * These constants are shared between runChildPi (in child-pi.ts) and the kill
+ * helpers (in child-pi-kill.ts). Centralizing them here avoids circular imports
+ * and makes the timing budget configurable from one place.
+ */
+
+import { DEFAULT_CHILD_PI } from "../config/defaults.ts";
+
+/** Post-exit window during which stdio is guarded against late writes. */
+export const POST_EXIT_STDIO_GUARD_MS = DEFAULT_CHILD_PI.postExitStdioGuardMs;
+
+/** Maximum time to wait for a final assistant event after the last stdout byte. */
+export const FINAL_DRAIN_MS = DEFAULT_CHILD_PI.finalDrainMs;
+
+/** Time after SIGTERM to escalate to SIGKILL. */
+export const HARD_KILL_MS = DEFAULT_CHILD_PI.hardKillMs;
+
+/** Maximum time with no output before the child is considered unresponsive. */
+export const RESPONSE_TIMEOUT_MS = DEFAULT_CHILD_PI.responseTimeoutMs;
+
+/**
+ * Maximum size (bytes) for the ChildPiLineObserver's line accumulation buffer.
+ * When exceeded, the buffer is force-flushed to prevent unbounded memory growth
+ * from chatty child processes that produce output without newlines.
+ */
+export const MAX_LINE_BUFFER_BYTES = 1024 * 1024; // 1 MB
+
+/** Maximum characters for assistant text fragments in compacted events. */
+export const MAX_ASSISTANT_TEXT_CHARS = DEFAULT_CHILD_PI.maxAssistantTextChars;
+
+/** Maximum characters for tool-result fragments in compacted events. */
+export const MAX_TOOL_RESULT_CHARS = DEFAULT_CHILD_PI.maxToolResultChars;
+
+/** Maximum characters for tool-input fragments in compacted events. */
+export const MAX_TOOL_INPUT_CHARS = DEFAULT_CHILD_PI.maxToolInputChars;
+
+/** Maximum characters for general compactable content (used by TruncationStage). */
+export const MAX_COMPACT_CONTENT_CHARS = DEFAULT_CHILD_PI.maxCompactContentChars;

package/src/runtime/child-pi-kill.ts

@@ -0,0 +1,180 @@
+/**
+ * child-pi-kill.ts — Kill/escape path for child Pi worker processes.
+ *
+ * Extracted from child-pi.ts (H-7 decomposition, step 2). Zero behavior change.
+ *
+ * Responsibilities:
+ *   - appendBoundedTail(): bounded concatenation with truncation marker.
+ *   - killProcessPid(): send SIGTERM → SIGKILL escalation, with Windows taskkill fallback.
+ *   - killProcessTree(): log+kill a child by pid, optionally attach exit listener to clear timer.
+ *   - terminateActiveChildPiProcesses(): kill all known active children.
+ *   - registerActiveChild()/unregisterActiveChild(): book-keeping for the active-children Map.
+ *   - Periodic zombie reaper (setInterval) that drops dead entries.
+ *
+ * The activeChildrenMap and hardKillTimers Map are kept here (not re-exported)
+ * because they are tightly coupled to the kill lifecycle.
+ */
+
+import type { ChildProcess } from "node:child_process";
+import { spawn } from "node:child_process";
+import { DEFAULT_CHILD_PI } from "../config/defaults.ts";
+import { logInternalError } from "../utils/internal-error.ts";
+import { HARD_KILL_MS } from "./child-pi-constants.ts";
+import { TailCaptureStage } from "./compact-stages/tail-capture-stage.ts";
+
+const MAX_CAPTURE_BYTES = DEFAULT_CHILD_PI.maxCaptureBytes;
+
+// Active children bookkeeping. Mutated by registerActiveChild/unregisterActiveChild.
+const activeChildProcesses = new Map<number, ChildProcess>();
+const childHardKillTimers = new Map<number, NodeJS.Timeout>();
+
+// Periodic cleanup of dead child process entries to prevent memory leaks.
+// If a child process never emits exit/close (zombie), the entry would leak.
+setInterval(() => {
+	for (const [pid, child] of activeChildProcesses) {
+		try {
+			process.kill(pid, 0); // Throws ESRCH if dead
+		} catch {
+			activeChildProcesses.delete(pid);
+		}
+	}
+}, 60_000).unref();
+
+/** Register a newly-spawned child so it can be tracked + killed on shutdown. */
+export function registerActiveChild(pid: number, child: ChildProcess): void {
+	activeChildProcesses.set(pid, child);
+}
+
+/** Remove a child from the active set once it has exited (or before kill). */
+export function unregisterActiveChild(pid: number): void {
+	activeChildProcesses.delete(pid);
+}
+
+/** Clear the SIGKILL escalation timer for a pid (called on early exit). */
+export function clearHardKillTimer(pid: number | undefined): void {
+	if (pid === undefined) return;
+	const timer = childHardKillTimers.get(pid);
+	if (timer) {
+		clearTimeout(timer);
+		childHardKillTimers.delete(pid);
+	}
+}
+
+/**
+ * Append `chunk` to `current`, keeping the result within `maxBytes`. When the
+ * cap is exceeded, returns the tail (most recent bytes) prefixed with a marker
+ * showing how much was dropped. Delegates to TailCaptureStage so the logic
+ * stays consistent with the rest of the compaction pipeline.
+ */
+export function appendBoundedTail(current: string, chunk: string, maxBytes = MAX_CAPTURE_BYTES): string {
+	return new TailCaptureStage({
+		maxBytes,
+		marker: `[pi-crew captured output truncated to last ${Math.round(maxBytes / 1024)} KiB]`,
+	}).apply(current + chunk);
+}
+
+function spawnTaskkillSafe(pid: number): void {
+	// B6: spawn taskkill and attach an 'error' listener. spawn() emits ENOENT/EACCES
+	// via the 'error' event — unhandled these would become uncaughtException and
+	// can crash the parent as an uncaught exception. taskkill is a standard Windows
+	// utility and rarely fails to spawn, but be defensive.
+	try {
+		const taskkillChild = spawn("taskkill", ["/pid", String(pid), "/t", "/f"], {
+			stdio: "ignore",
+			detached: false,
+		});
+		taskkillChild.on("error", (err) => {
+			logInternalError("child-pi.taskkill-spawn-error", err instanceof Error ? err : new Error(String(err)), `pid=${pid}`);
+		});
+		taskkillChild.unref();
+	} catch (error) {
+		logInternalError("child-pi.taskkill-sync-error", error instanceof Error ? error : new Error(String(error)), `pid=${pid}`);
+	}
+}
+
+export function killProcessPid(pid: number): void {
+	if (!Number.isInteger(pid) || pid <= 0) return;
+	try {
+		if (process.platform === "win32") {
+			// 3.8: Windows path uses taskkill /T /F (force kill the entire tree).
+			// taskkill itself can silently fail (PID gone, permission denied, etc.)
+			// so verify after 2s and log a warning if the process is still alive.
+			spawnTaskkillSafe(pid);
+			const verifyTimer = setTimeout(() => {
+				try {
+					process.kill(pid, 0); // throws ESRCH when dead
+					// Still alive — log and retry once.
+					logInternalError(
+						"child-pi.taskkill-stuck",
+						new Error(`process ${pid} still alive 2s after taskkill /T /F; retrying`),
+						`pid=${pid}`,
+						"error",
+					);
+					try {
+						spawnTaskkillSafe(pid);
+					} catch {
+						/* best-effort */
+					}
+				} catch {
+					// ESRCH or EPERM — process is gone. OK.
+				}
+			}, 2000);
+			verifyTimer.unref();
+			return;
+		}
+		try {
+			process.kill(-pid, "SIGTERM");
+		} catch (error) {
+			logInternalError("child-pi.sigterm", error, `pid=${pid}`);
+			try {
+				process.kill(pid, "SIGTERM");
+			} catch (fallbackError) {
+				logInternalError("child-pi.sigterm-absolute", fallbackError, `pid=${pid}`);
+			}
+		}
+		clearHardKillTimer(pid);
+		const hardKillTimer = setTimeout(() => {
+			try {
+				process.kill(-pid, "SIGKILL");
+			} catch (error) {
+				logInternalError("child-pi.sigkill", error, `pid=${pid}`);
+				try {
+					process.kill(pid, "SIGKILL");
+				} catch (fallbackError) {
+					logInternalError("child-pi.sigkill-absolute", fallbackError, `pid=${pid}`);
+				}
+			}
+			childHardKillTimers.delete(pid);
+		}, HARD_KILL_MS);
+		hardKillTimer.unref();
+		childHardKillTimers.set(pid, hardKillTimer);
+	} catch (error) {
+		logInternalError("child-pi.kill-process-pid", error, `pid=${pid}`);
+	}
+}
+
+export function killProcessTree(pid: number | undefined, child?: ChildProcess): void {
+	// Phase-0 diagnostic (HB-003a): capture who invoked killProcessTree so the
+	// exit-null race has a provenance trail. .stack is best-effort (may be undefined
+	// under deep async), so we take a snapshot lazily.
+	try {
+		const callerStack = new Error("killProcessTree caller").stack ?? "(no stack)";
+		logInternalError(
+			"child-pi.kill-process-tree-invoked",
+			new Error(`pid=${pid} called from:\n${callerStack.split("\n").slice(0, 8).join("\n")}`),
+			`pid=${pid}`,
+		);
+	} catch {
+		/* diagnostic best-effort */
+	}
+	if (!pid || !Number.isInteger(pid) || pid <= 0) return;
+	if (child && child.exitCode !== null) return;
+	killProcessPid(pid);
+	child?.once("exit", () => clearHardKillTimer(pid));
+}
+
+export function terminateActiveChildPiProcesses(): number {
+	const entries = [...activeChildProcesses.entries()];
+	for (const [pid, child] of entries) killProcessTree(pid, child);
+	return entries.length;
+}