pi-crew 0.9.35 → 0.9.37

package/package.json

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

package/src/extension/register.ts

@@ -130,6 +130,7 @@ function purgeStaleActiveRunIndexSyncIfLoaded(): void {
 
 import { pruneFinishedRuns, pruneUserLevelRuns } from "../extension/run-maintenance.ts";
 import { initI18n } from "../i18n.ts";
+import { globalProgressTracker } from "../runtime/progress-tracker.ts";
 // H3-L2 split: DeliveryCoordinator + OverflowRecoveryTracker moved to registration/lifecycle.ts.
 import { tryRegisterSessionCleanup } from "../runtime/session-resources.ts";
 import { createSessionSnapshot } from "../runtime/session-snapshot.ts";
@@ -1474,6 +1475,11 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 			const record = event as Record<string, unknown>;
 			const eventType = typeof record.type === "string" ? record.type : undefined;
 			if (eventType) lifecycleState.overflowTracker?.feedEvent(taskId, runId, eventType);
+			// Phase 2: forward worker events to progress tracker for real-time
+			// widget display (tool calls, assistant text) on child-process runtime.
+			if (record && typeof record === "object") {
+				globalProgressTracker.handleWorkerEvent(taskId, runId, record);
+			}
 		},
 	});
 	registerSubagentTools(pi, subagentManager, {

package/src/extension/registration/subagent-tools.ts

@@ -23,6 +23,7 @@ import { loadConfig } from "../../config/config.ts";
 import { t } from "../../i18n.ts";
 import type { BatchBarrier } from "../../runtime/batch-barrier.ts";
 import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
+import { globalProgressTracker } from "../../runtime/progress-tracker.ts";
 import { checkSubagentSpawnPermission, currentCrewRole } from "../../runtime/role-permission.ts";
 import { loadRunManifestById } from "../../state/state-store.ts";
 import {
@@ -444,7 +445,23 @@ function startAgentToolProgress(cwd: string, agentRecordId: string, onUpdate: On
 				agents,
 				error: record.error,
 			});
-			onUpdate({ content: [{ type: "text", text }] });
+			// Phase 2C: enrich with real-time worker progress (tool calls, partial text)
+			// from globalProgressTracker. For foreground agents, find the task ID from
+			// the manifest and look up streaming progress.
+			let progressLine = text;
+			if (tasks && tasks.length > 0) {
+				const wp = globalProgressTracker.getWorkerProgress(tasks[0].id);
+				if (wp) {
+					const toolLine = wp.currentTool ? `\n  ⚡ tool: ${wp.currentTool}` : "";
+					const tokenLine =
+						wp.tokens.input + wp.tokens.output > 0
+							? `\n  📊 tokens: ${(wp.tokens.input / 1000).toFixed(1)}K in, ${(wp.tokens.output / 1000).toFixed(1)}K out`
+							: "";
+					const textLine = wp.partialText ? `\n  💬 ${wp.partialText.slice(-150).replace(/\n/g, " ")}` : "";
+					progressLine = `${text}${toolLine}${tokenLine}${textLine}`;
+				}
+			}
+			onUpdate({ content: [{ type: "text", text: progressLine }] });
 		} catch (error) {
 			logInternalError("subagent-tools.progress", error, `agentId=${agentRecordId}`);
 		}

package/src/extension/team-tool/context.ts

@@ -47,6 +47,40 @@ function extractTextContent(content: unknown): string {
 		.join("\n");
 }
 
+/**
+ * Maximum character budget for inherited parent context (~3K tokens).
+ * When exceeded, oldest messages are dropped first (most-recent-first retention).
+ */
+export const MAX_PARENT_CONTEXT_CHARS = 12_000;
+
+/** Maximum chars for a single assistant message before truncation. */
+const MAX_ASSISTANT_MSG_CHARS = 500;
+
+/** Truncated length for oversized assistant messages. */
+const TRUNCATED_ASSISTANT_CHARS = 200;
+
+/** Messages starting with these patterns and exceeding this size are likely
+ *  file dumps / bash output — skip them to keep context relevant and compact. */
+const NOISY_THRESHOLD = 1_000;
+const NOISY_PREFIXES = ["```", "total ", "drwx", "-rw", "import ", "export "];
+
+/**
+ * Check if a message looks like noisy file/tool output (code dumps, ls output,
+ * import lists) that bloats context without helping the subagent.
+ */
+function isNoisyContent(text: string): boolean {
+	if (text.length < NOISY_THRESHOLD) return false;
+	return NOISY_PREFIXES.some((prefix) => text.startsWith(prefix));
+}
+
+/**
+ * Build a compact parent conversation context for subagent inheritance.
+ *
+ * Extracts recent user messages, assistant reasoning, and compaction summaries
+ * from the parent session. Applies a character budget (most-recent-first
+ * retention) and filters noisy content (file dumps, long bash output) to keep
+ * the inherited context relevant without bloating the subagent's token budget.
+ */
 export function buildParentContext(ctx: TeamContext): string | undefined {
 	const branch = ctx.sessionManager?.getBranch?.();
 	if (!Array.isArray(branch) || branch.length === 0) return undefined;
@@ -58,21 +92,43 @@ export function buildParentContext(ctx: TeamContext): string | undefined {
 			message?: unknown;
 			summary?: unknown;
 		};
-		if (record.type === "compaction" && typeof record.summary === "string") parts.push(`[Summary]: ${record.summary}`);
+		// Compaction summaries are always valuable — keep in full.
+		if (record.type === "compaction" && typeof record.summary === "string") {
+			parts.push(`[Summary]: ${record.summary}`);
+			continue;
+		}
 		const message =
 			record.message && typeof record.message === "object" && !Array.isArray(record.message)
 				? (record.message as { role?: unknown; content?: unknown })
 				: undefined;
 		if (!message || (message.role !== "user" && message.role !== "assistant")) continue;
-		const text = extractTextContent(message.content).trim();
-		if (text) parts.push(`[${message.role === "user" ? "User" : "Assistant"}]: ${text}`);
+		let text = extractTextContent(message.content).trim();
+		if (!text) continue;
+		// Filter: skip noisy content (file dumps, long bash output).
+		if (isNoisyContent(text)) continue;
+		// Truncate: long assistant messages get shortened to key points.
+		if (message.role === "assistant" && text.length > MAX_ASSISTANT_MSG_CHARS) {
+			text = `${text.slice(0, TRUNCATED_ASSISTANT_CHARS)}…`;
+		}
+		parts.push(`[${message.role === "user" ? "User" : "Assistant"}]: ${text}`);
 	}
 	if (!parts.length) return undefined;
+
+	// Budget: keep most-recent messages first, drop oldest when over budget.
+	let totalChars = 0;
+	const budgeted: string[] = [];
+	for (const part of [...parts].reverse()) {
+		if (totalChars + part.length > MAX_PARENT_CONTEXT_CHARS) break;
+		budgeted.unshift(part);
+		totalChars += part.length;
+	}
+	if (!budgeted.length) return undefined;
+
 	return [
 		`# Parent Conversation Context`,
 		"The following context was inherited from the parent Pi session. Treat it as reference-only.",
 		"",
-		parts.join("\n\n"),
+		budgeted.join("\n\n"),
 	].join("\n");
 }
 

package/src/extension/team-tool/handle-settings.ts

@@ -14,7 +14,7 @@ const EFFECTIVE_DEFAULTS: Record<string, unknown> = {
 	"runtime.mode": "auto",
 	"runtime.maxTurns": 10000,
 	"runtime.graceTurns": 5,
-	"runtime.inheritContext": false,
+	"runtime.inheritContext": true,
 	"runtime.promptMode": "replace",
 	"runtime.completionMutationGuard": "warn",
 	"runtime.isolationPolicy": undefined,

package/src/runtime/async-runner.ts

@@ -210,7 +210,7 @@ export const BACKGROUND_RUNNER_ENV_ALLOWLIST: string[] = [
 	// Phase 1.5: worker-thread atomic writer opt-in (RFC 15).
 	"PI_CREW_WORKER_ATOMIC_WRITER",
 	"PI_TEAMS_WORKER_ATOMIC_WRITER",
-	// Phase 1.5 #1: verification env sanitization opt-in (RFC 13 §6).
+	// Phase 1.5 #1: verification env sanitization opt-out (RFC 13 §6).
 	"PI_CREW_VERIFICATION_SANITIZE_ENV",
 	"PI_TEAMS_VERIFICATION_SANITIZE_ENV",
 	"PI_CREW_VERIFICATION_PRESERVE_ENV",

package/src/runtime/progress-tracker.ts

@@ -9,6 +9,8 @@ export interface AgentProgress {
 	turns: number;
 	tokens: { input: number; output: number };
 	status: "idle" | "running" | "completed" | "error";
+	/** Most recent partial assistant text (for live streaming display). */
+	partialText?: string;
 }
 
 export class ProgressTracker {
@@ -118,7 +120,145 @@ export class ProgressTracker {
 	getProgress(agentId: string): AgentProgress | undefined {
 		return this.sessions.get(agentId)?.progress;
 	}
+
+	// ── Child-process worker event bridge ──────────────────────────────────
+	//
+	// For child-process runtime, events arrive as raw JSON from the child pi
+	// process's stdout (via onJsonEvent). These methods bridge those events into
+	// the same crewEventBus stream that live-session uses, so the widget shows
+	// real-time tool calls and assistant text for BOTH runtimes.
+
+	private workerProgress = new Map<string, AgentProgress>();
+
+	/** Throttle: don't emit more than 1 progress event per 500ms per worker. */
+	private lastEmitTs = new Map<string, number>();
+	private static readonly EMIT_THROTTLE_MS = 500;
+
+	/**
+	 * Handle a raw child-process JSON event (from onJsonEvent callback).
+	 * Processes tool_execution_start/end, agent_start/end, and assistant text.
+	 */
+	handleWorkerEvent(taskId: string, runId: string, event: Record<string, unknown>): void {
+		let progress = this.workerProgress.get(taskId);
+		if (!progress) {
+			progress = {
+				toolCalls: 0,
+				currentTool: null,
+				toolStartTime: null,
+				errors: [],
+				turns: 0,
+				tokens: { input: 0, output: 0 },
+				status: "running",
+			};
+			this.workerProgress.set(taskId, progress);
+		}
+
+		const eventType = typeof event.type === "string" ? event.type : undefined;
+
+		switch (eventType) {
+			case "tool_execution_start": {
+				progress.toolCalls++;
+				progress.currentTool = typeof event.toolName === "string" ? event.toolName : "unknown";
+				progress.toolStartTime = Date.now();
+				this.emitThrottled(taskId, runId, progress);
+				break;
+			}
+			case "tool_execution_end": {
+				progress.currentTool = null;
+				progress.toolStartTime = null;
+				if (event.isError) {
+					progress.errors.push(String(event.result ?? "Unknown error"));
+					crewEventBus.emit({
+						type: "agent:error",
+						runId,
+						agentId: taskId,
+						payload: String(event.result ?? "Unknown error"),
+						timestamp: Date.now(),
+					});
+				}
+				this.emitThrottled(taskId, runId, progress);
+				break;
+			}
+			case "turn_start":
+			case "turn_end":
+				progress.turns++;
+				break;
+			case "agent_start":
+				progress.status = "running";
+				break;
+			case "agent_end":
+			case "agent_settled":
+				progress.status = "completed";
+				this.emitThrottled(taskId, runId, progress);
+				break;
+			case "message":
+			case "message_end": {
+				// Extract assistant text for streaming display.
+				const message = event.message as { role?: string; content?: unknown } | undefined;
+				if (message?.role === "assistant") {
+					const text = extractWorkerText(message.content);
+					if (text) {
+						progress.partialText = text.slice(-2000); // keep last 2K chars
+						this.emitThrottled(taskId, runId, progress);
+					}
+				}
+				// Track usage from message_end events.
+				if (eventType === "message_end" && event.usage && typeof event.usage === "object") {
+					const usage = event.usage as { input?: number; output?: number };
+					if (typeof usage.input === "number") progress.tokens.input += usage.input;
+					if (typeof usage.output === "number") progress.tokens.output += usage.output;
+				}
+				break;
+			}
+		}
+	}
+
+	/** Get the accumulated progress for a child-process worker task. */
+	getWorkerProgress(taskId: string): AgentProgress | undefined {
+		return this.workerProgress.get(taskId);
+	}
+
+	/** Remove a worker from tracking after completion. */
+	untrackWorker(taskId: string): void {
+		this.workerProgress.delete(taskId);
+		this.lastEmitTs.delete(taskId);
+	}
+
+	/**
+	 * Emit a progress event to crewEventBus, throttled to avoid flooding
+	 * the widget with re-renders (max 1 event per EMIT_THROTTLE_MS per worker).
+	 */
+	private emitThrottled(taskId: string, runId: string, progress: AgentProgress): void {
+		const now = Date.now();
+		const last = this.lastEmitTs.get(taskId) ?? 0;
+		if (now - last < ProgressTracker.EMIT_THROTTLE_MS) return;
+		this.lastEmitTs.set(taskId, now);
+		crewEventBus.emit({
+			type: "agent:progress",
+			runId,
+			agentId: taskId,
+			payload: { ...progress },
+			timestamp: now,
+		});
+	}
 }
 
 // Export singleton instance
 export const globalProgressTracker = new ProgressTracker();
+
+/**
+ * Extract text content from a worker message's content field.
+ * Handles string content and array-of-parts (like extractTextContent in context.ts).
+ */
+function extractWorkerText(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content
+		.map((part) =>
+			part && typeof part === "object" && !Array.isArray(part) && typeof (part as { text?: unknown }).text === "string"
+				? (part as { text: string }).text
+				: "",
+		)
+		.filter(Boolean)
+		.join("\n");
+}

package/src/runtime/verification-gates.ts

@@ -25,8 +25,9 @@ import { redactSecretString } from "../utils/redaction.ts";
  * against adversarial workers; this kills the leak at the source by never
  * giving the verification process the secret in the first place.
  *
- * Opt-in via `PI_CREW_VERIFICATION_SANITIZE_ENV=1` to avoid breaking existing
- * flows whose tests legitimately need API access. Escape hatch:
+ * Opt-out via `PI_CREW_VERIFICATION_SANITIZE_ENV=0` or
+ * `PI_TEAMS_VERIFICATION_SANITIZE_ENV=0` to disable sanitization (e.g. for
+ * tests that legitimately need API access). Escape hatch:
  * `PI_CREW_VERIFICATION_PRESERVE_ENV=KEY1,KEY2,...` lets users explicitly opt
  * specific secrets back in (audited via the allowlist validator).
  */
@@ -62,9 +63,13 @@ const VERIFICATION_ENV_ALLOWLIST: readonly string[] = [
 	"NPM_CONFIG_GLOBALCONFIG",
 ];
 
-/** Whether env sanitization for verification is enabled (env var opt-in). */
+/** Whether env sanitization for verification is enabled (opt-out: enabled by default). */
 export function isVerificationEnvSanitizeEnabled(): boolean {
-	return process.env.PI_CREW_VERIFICATION_SANITIZE_ENV === "1" || process.env.PI_TEAMS_VERIFICATION_SANITIZE_ENV === "1";
+	// Opt-out: explicitly disabled via env var set to '0'.
+	if (process.env.PI_CREW_VERIFICATION_SANITIZE_ENV === "0" || process.env.PI_TEAMS_VERIFICATION_SANITIZE_ENV === "0") {
+		return false;
+	}
+	return true;
 }
 
 /**

package/src/state/instinct-store.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { assertSafePathId } from "../utils/safe-paths.ts";
 
 /**
  * Represents a learned instinct that guides agent behavior.
@@ -120,6 +121,7 @@ export class InstinctStore {
 			if (!savedInstinct.projectId) {
 				throw new Error("Project-scoped instinct requires a projectId");
 			}
+			assertSafePathId("projectId", savedInstinct.projectId);
 			this.appendInstinctToFile(this.getProjectInstinctPath(savedInstinct.projectId), savedInstinct);
 		}
 
@@ -163,6 +165,7 @@ export class InstinctStore {
 	 * @returns Array of instincts for the project
 	 */
 	getProjectInstincts(projectId: string): Instinct[] {
+		assertSafePathId("projectId", projectId);
 		const projectInstincts = this.readInstinctsFromFile(this.getProjectInstinctPath(projectId));
 		const globalInstincts = this.readInstinctsFromFile(this.getGlobalInstinctPath());
 		return [...projectInstincts, ...globalInstincts];
@@ -183,6 +186,7 @@ export class InstinctStore {
 				.readdirSync(projectsDir, { withFileTypes: true })
 				.filter((e) => e.isDirectory())
 				.map((e) => e.name)) {
+				assertSafePathId("projectId", projectId);
 				const filePath = path.join(projectsDir, projectId, INSTINCT_FILE);
 				const instincts = this.readInstinctsFromFile(filePath);
 				const index = instincts.findIndex((i) => i.id === instinctId);
@@ -239,6 +243,7 @@ export class InstinctStore {
 				.readdirSync(projectsDir, { withFileTypes: true })
 				.filter((e) => e.isDirectory())
 				.map((e) => e.name)) {
+				assertSafePathId("projectId", projectId);
 				const filePath = path.join(projectsDir, projectId, INSTINCT_FILE);
 				instincts = this.readInstinctsFromFile(filePath);
 				index = instincts.findIndex((i) => i.id === instinctId);

package/src/ui/settings-overlay.ts

@@ -327,7 +327,7 @@ const EFFECTIVE_DEFAULTS: Record<string, unknown> = {
 	"runtime.mode": "auto",
 	"runtime.maxTurns": 10000,
 	"runtime.graceTurns": 5,
-	"runtime.inheritContext": false,
+	"runtime.inheritContext": true,
 	"runtime.promptMode": "replace",
 	"runtime.completionMutationGuard": "warn",
 	"runtime.isolationPolicy": undefined,

package/src/workflows/intermediate-store.ts

@@ -56,6 +56,11 @@ export function ensureIntermediateDir(config: Partial<IntermediateStoreConfig> =
  * @returns Path to the written file
  */
 export function writeIntermediate(config: Partial<IntermediateStoreConfig>, phase: string, stepId: string, data: unknown): string {
+	// Security: validate phase/stepId before building the filename to prevent
+	// path traversal via poisoned phase or stepId.
+	if (!isSafePathId(phase) || !isSafePathId(stepId)) {
+		throw new Error("Invalid phase or stepId for intermediate store");
+	}
 	const dir = ensureIntermediateDir(config);
 	const filename = `${phase}-${stepId}.json`;
 	const filePath = path.join(dir, filename);