pi-crew 0.5.2 → 0.5.6

package/src/extension/team-tool/auto-summarize.ts

@@ -0,0 +1,154 @@
+/**
+ * Auto-summarize commands for team tool.
+ * Provides on/off/status commands for auto-summarization.
+ */
+
+import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
+import type { PiTeamsToolResult } from "../tool-result.ts";
+import { result, type TeamContext } from "./context.ts";
+import {
+	AutoSummarizeService,
+	createAutoSummarizeService,
+	DEFAULT_AUTO_SUMMARIZE_CONFIG,
+} from "../../runtime/auto-summarize.ts";
+
+// Global auto-summarize service instance for CLI usage
+let globalAutoSummarize: AutoSummarizeService | null = null;
+
+function getAutoSummarize(): AutoSummarizeService {
+	if (!globalAutoSummarize) {
+		globalAutoSummarize = createAutoSummarizeService();
+	}
+	return globalAutoSummarize;
+}
+
+export function handleAutoSummarizeOn(
+	params: TeamToolParamsValue,
+	ctx: TeamContext,
+): PiTeamsToolResult {
+	const service = getAutoSummarize();
+	const cfg = params.config ?? {};
+
+	// Apply config updates if provided
+	if (cfg.threshold !== undefined) {
+		const threshold = typeof cfg.threshold === "number" ? cfg.threshold : parseInt(String(cfg.threshold), 10);
+		if (!isNaN(threshold) && threshold >= 0) {
+			service.setThreshold(threshold);
+		}
+	}
+
+	if (cfg.minTools !== undefined) {
+		const minTools = typeof cfg.minTools === "number" ? cfg.minTools : parseInt(String(cfg.minTools), 10);
+		if (!isNaN(minTools) && minTools >= 0) {
+			service.setMinToolsUsed(minTools);
+		}
+	}
+
+	const previousState = service.isEnabled();
+	service.enable();
+	const config = service.getConfig();
+
+	return result(
+		[
+			`Auto-summarize enabled.`,
+			``,
+			`Configuration:`,
+			`  Token threshold: ${config.threshold}`,
+			`  Min tools: ${config.minToolsUsed}`,
+			`  Collapse context: ${config.collapseContext}`,
+		].join("\n"),
+		{ action: "auto-summarize", status: "ok" },
+	);
+}
+
+export function handleAutoSummarizeOff(
+	params: TeamToolParamsValue,
+	ctx: TeamContext,
+): PiTeamsToolResult {
+	const service = getAutoSummarize();
+
+	service.disable();
+
+	return result(
+		"Auto-summarize disabled.",
+		{ action: "auto-summarize", status: "ok" },
+	);
+}
+
+export function handleAutoSummarizeStatus(
+	params: TeamToolParamsValue,
+	ctx: TeamContext,
+): PiTeamsToolResult {
+	const service = getAutoSummarize();
+	const config = service.getConfig();
+	const isEnabled = service.isEnabled();
+
+	return result(
+		[
+			`Auto-summarize Status`,
+			`──────────────────`,
+			`Enabled: ${isEnabled ? "Yes" : "No"}`,
+			``,
+			`Configuration:`,
+			`  Token threshold: ${config.threshold} (default: ${DEFAULT_AUTO_SUMMARIZE_CONFIG.threshold})`,
+			`  Min tools used: ${config.minToolsUsed} (default: ${DEFAULT_AUTO_SUMMARIZE_CONFIG.minToolsUsed})`,
+			`  Collapse context: ${config.collapseContext ? "Yes" : "No"} (default: ${DEFAULT_AUTO_SUMMARIZE_CONFIG.collapseContext ? "Yes" : "No"})`,
+			``,
+			`Triggers:`,
+			`  - Token count >= ${config.threshold}`,
+			`  - Tool count >= ${config.minToolsUsed}`,
+			`  - High token-to-tool ratio (>1000 tokens/tool with 3+ tools)`,
+		].join("\n"),
+		{ action: "auto-summarize", status: "ok" },
+	);
+}
+
+export function handleAutoSummarizeConfig(
+	params: TeamToolParamsValue,
+	ctx: TeamContext,
+): PiTeamsToolResult {
+	const service = getAutoSummarize();
+	const cfg = params.config ?? {};
+
+	// Parse config options
+	const updates: { threshold?: number; minTools?: number; collapseContext?: boolean } = {};
+
+	if (cfg.threshold !== undefined) {
+		const threshold = typeof cfg.threshold === "number" ? cfg.threshold : parseInt(String(cfg.threshold), 10);
+		if (!isNaN(threshold) && threshold >= 0) {
+			updates.threshold = threshold;
+		}
+	}
+
+	if (cfg.minTools !== undefined) {
+		const minTools = typeof cfg.minTools === "number" ? cfg.minTools : parseInt(String(cfg.minTools), 10);
+		if (!isNaN(minTools) && minTools >= 0) {
+			updates.minTools = minTools;
+		}
+	}
+
+	if (cfg.collapseContext !== undefined) {
+		updates.collapseContext = Boolean(cfg.collapseContext);
+	}
+
+	if (Object.keys(updates).length > 0) {
+		service.updateConfig(updates);
+	}
+
+	const config = service.getConfig();
+
+	return result(
+		[
+			`Auto-summarize configuration updated.`,
+			``,
+			`Current settings:`,
+			`  Token threshold: ${config.threshold}`,
+			`  Min tools used: ${config.minToolsUsed}`,
+			`  Collapse context: ${config.collapseContext ? "Yes" : "No"}`,
+			`  Enabled: ${config.enabled ? "Yes" : "No"}`,
+		].join("\n"),
+		{ action: "auto-summarize", status: "ok" },
+	);
+}
+// Re-export for team-tool.ts
+export { createAutoSummarizeService } from "../../runtime/auto-summarize.ts";

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

@@ -8,10 +8,12 @@ import { registerActiveRun, unregisterActiveRun } from "../../state/active-run-r
 import { createRunManifest, loadRunManifestById, updateRunStatus } from "../../state/state-store.ts";
 import { atomicWriteJson } from "../../state/atomic-write.ts";
 import { validateWorkflowForTeam } from "../../workflows/validate-workflow.ts";
+import { PipelineRunner, type PipelineWorkflow, type PipelineStage } from "../../runtime/pipeline-runner.ts";
 // Heavy runtime — lazy-loaded to avoid 1.4s import cost at extension registration.
 import type { executeTeamRun as ExecuteTeamRunFn } from "../../runtime/team-runner.ts";
 // eslint-disable-next-line @typescript-eslint/no-unused-vars -- type-only import for TS inference
 const _typeCheck: typeof ExecuteTeamRunFn = null as never as typeof ExecuteTeamRunFn;
+import { logInternalError } from "../../utils/internal-error.ts";
 let _cachedExecuteTeamRun: typeof ExecuteTeamRunFn | undefined;
 async function executeTeamRun(...args: Parameters<typeof ExecuteTeamRunFn>): Promise<Awaited<ReturnType<typeof ExecuteTeamRunFn>>> {
 	if (!_cachedExecuteTeamRun) {
@@ -22,7 +24,7 @@ async function executeTeamRun(...args: Parameters<typeof ExecuteTeamRunFn>): Pro
 	return _cachedExecuteTeamRun(...args);
 }
 import { spawnBackgroundTeamRun } from "../../subagents/async-entry.ts";
-import { appendEvent, readEvents } from "../../state/event-log.ts";
+import { appendEvent, appendEventAsync, readEvents } from "../../state/event-log.ts";
 import { resolveCrewRuntime, runtimeResolutionState } from "../../runtime/runtime-resolver.ts";
 import { normalizeSkillOverride } from "../../runtime/skill-instructions.ts";
 import { expandParallelResearchWorkflow } from "../../runtime/parallel-research.ts";
@@ -67,7 +69,7 @@ function scheduleBackgroundEarlyExitGuard(cwd: string, runId: string, pid: numbe
 		const tail = tailFile(logPath);
 		const message = `Background runner exited within 3s; see background.log${tail ? `\n${tail}` : ""}`;
 		const failed = updateRunStatus(loaded.manifest, "failed", "Background runner exited within 3s; see background.log");
-		appendEvent(failed.eventsPath, { type: "async.failed", runId: failed.runId, message, data: { pid, detail: liveness.detail } });
+		void appendEventAsync(failed.eventsPath, { type: "async.failed", runId: failed.runId, message, data: { pid, detail: liveness.detail } });
 	}, 3000);
 	timer.unref();
 }
@@ -110,6 +112,39 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	if (!baseWorkflow) return result(`Workflow '${workflowName}' not found.`, { action: "run", status: "error" }, true);
 	const workflow = directAgent ? baseWorkflow : expandParallelResearchWorkflow(baseWorkflow, ctx.cwd);
 
+	// Check if this is a pipeline workflow - special handling for multi-stage execution
+	const isPipelineWorkflow = workflowName === "pipeline" && !directAgent;
+	if (isPipelineWorkflow) {
+		// For pipeline workflows, use PipelineRunner for execution
+		const pipelineRunner = new PipelineRunner();
+		const pipelineWorkflow: PipelineWorkflow = {
+			name: workflow.name,
+			description: workflow.description,
+			goal,
+			stages: workflow.steps.map((step) => ({
+				name: step.id,
+				team: step.role,
+				inputs: step.task,
+				usePreviousResults: step.dependsOn && step.dependsOn.length > 0,
+			})),
+			stopOnError: true,
+			defaultMaxConcurrency: workflow.maxConcurrency ?? 5,
+		};
+
+		// For now, show pipeline workflow info - full integration would require
+		// connecting PipelineRunner to the actual team execution system
+		const stageInfo = pipelineWorkflow.stages.map((s) => `- ${s.name} (${s.team})`).join("\n");
+		return result([
+			`Pipeline workflow: ${workflow.name}`,
+			`Goal: ${goal}`,
+			`Stages (${pipelineWorkflow.stages.length}):`,
+			stageInfo,
+			"",
+			"Pipeline execution is available via the PipelineRunner API.",
+			"Full CLI integration requires connecting to the team execution system.",
+		].join("\n"), { action: "run", status: "ok" }, false);
+	}
+
 	const validationErrors = validateWorkflowForTeam(workflow, team);
 	if (validationErrors.length > 0) {
 		return result([`Workflow '${workflow.name}' is not valid for team '${team.name}':`, ...validationErrors.map((error) => `- ${error}`)].join("\n"), { action: "run", status: "error" }, true);
@@ -140,7 +175,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	const runtimeResolution = runtimeResolutionState(runtime);
 	const executionManifest = { ...updatedManifest, runtimeResolution, runConfig: executedConfig, updatedAt: new Date().toISOString() };
 	atomicWriteJson(paths.manifestPath, executionManifest);
-	appendEvent(executionManifest.eventsPath, { type: "runtime.resolved", runId: executionManifest.runId, message: `Runtime resolved: ${runtime.kind} safety=${runtime.safety}`, data: { runtimeResolution } });
+	appendEventAsync(executionManifest.eventsPath, { type: "runtime.resolved", runId: executionManifest.runId, message: `Runtime resolved: ${runtime.kind} safety=${runtime.safety}`, data: { runtimeResolution } }).catch((error) => logInternalError("team-tool.run.resolved", error, `runId=${executionManifest.runId}`));
 	const runAsync = params.async ?? executedConfig.asyncByDefault ?? false;
 	let effectiveRuntime = runtime;
 	if (runAsync && runtime.kind === "live-session") {
@@ -150,13 +185,13 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	const effectiveManifest = effectiveRuntime !== runtime ? { ...executionManifest, runtimeResolution: effectiveRuntimeResolution, updatedAt: new Date().toISOString() } : executionManifest;
 	if (effectiveRuntime !== runtime) {
 		atomicWriteJson(paths.manifestPath, effectiveManifest);
-		appendEvent(effectiveManifest.eventsPath, { type: "runtime.resolved", runId: effectiveManifest.runId, message: `Runtime overridden: child-process (async fallback from live-session)`, data: { runtimeResolution: effectiveRuntimeResolution } });
+		appendEventAsync(effectiveManifest.eventsPath, { type: "runtime.resolved", runId: effectiveManifest.runId, message: `Runtime overridden: child-process (async fallback from live-session)`, data: { runtimeResolution: effectiveRuntimeResolution } }).catch((error) => logInternalError("team-tool.run.override", error, `runId=${effectiveManifest.runId}`));
 	}
 	if (runAsync) {
 		if (effectiveRuntime.safety === "blocked") {
 			const runningManifest = updateRunStatus(effectiveManifest, "running", "Checking worker runtime availability.");
 			const blocked = updateRunStatus(runningManifest, "blocked", effectiveRuntime.reason ?? "Child worker execution is disabled; refusing to create no-op scaffold subagents.");
-			appendEvent(blocked.eventsPath, { type: "run.blocked", runId: blocked.runId, message: blocked.summary, data: { runtime: effectiveRuntime, runtimeResolution: effectiveRuntimeResolution, async: true, diagnostics: { requestedMode: effectiveRuntime.requestedMode, workersDisabled: executedConfig.executeWorkers === false, envCrew: process.env.PI_CREW_EXECUTE_WORKERS, envTeams: process.env.PI_TEAMS_EXECUTE_WORKERS } } });
+			void appendEventAsync(blocked.eventsPath, { type: "run.blocked", runId: blocked.runId, message: blocked.summary, data: { runtime: effectiveRuntime, runtimeResolution: effectiveRuntimeResolution, async: true, diagnostics: { requestedMode: effectiveRuntime.requestedMode, workersDisabled: executedConfig.executeWorkers === false, envCrew: process.env.PI_CREW_EXECUTE_WORKERS, envTeams: process.env.PI_TEAMS_EXECUTE_WORKERS } } });
 			unregisterActiveRun(blocked.runId);
 			return result([
 				`Blocked pi-crew run ${blocked.runId}: real subagent workers are disabled.`,
@@ -169,7 +204,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		const spawned = await spawnBackgroundTeamRun(effectiveManifest);
 		const asyncManifest = { ...effectiveManifest, async: { pid: spawned.pid, logPath: spawned.logPath, spawnedAt: new Date().toISOString() } };
 		atomicWriteJson(paths.manifestPath, asyncManifest);
-		appendEvent(effectiveManifest.eventsPath, { type: "async.spawned", runId: effectiveManifest.runId, data: { pid: spawned.pid, logPath: spawned.logPath } });
+		void appendEventAsync(effectiveManifest.eventsPath, { type: "async.spawned", runId: effectiveManifest.runId, data: { pid: spawned.pid, logPath: spawned.logPath } });
 		scheduleBackgroundEarlyExitGuard(ctx.cwd, effectiveManifest.runId, spawned.pid, spawned.logPath);
 		// Wait for the async run to complete and return actual results.
 		try {
@@ -280,7 +315,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	if (runtime.safety === "blocked") {
 		const runningManifest = updateRunStatus(executionManifest, "running", "Checking worker runtime availability.");
 		const blocked = updateRunStatus(runningManifest, "blocked", runtime.reason ?? "Child worker execution is disabled; refusing to create no-op scaffold subagents.");
-		appendEvent(blocked.eventsPath, { type: "run.blocked", runId: blocked.runId, message: blocked.summary, data: { runtime, runtimeResolution, diagnostics: { requestedMode: runtime.requestedMode, workersDisabled: executedConfig.executeWorkers === false, envCrew: process.env.PI_CREW_EXECUTE_WORKERS, envTeams: process.env.PI_TEAMS_EXECUTE_WORKERS } } });
+		void appendEventAsync(blocked.eventsPath, { type: "run.blocked", runId: blocked.runId, message: blocked.summary, data: { runtime, runtimeResolution, diagnostics: { requestedMode: runtime.requestedMode, workersDisabled: executedConfig.executeWorkers === false, envCrew: process.env.PI_CREW_EXECUTE_WORKERS, envTeams: process.env.PI_TEAMS_EXECUTE_WORKERS } } });
 		unregisterActiveRun(blocked.runId);
 		return result([
 			`Blocked pi-crew run ${blocked.runId}: real subagent workers are disabled.`,

package/src/extension/team-tool.ts

@@ -170,6 +170,8 @@ import { handlePlan } from "./team-tool/plan.ts";
 import { handleOrchestrate } from "./team-tool/orchestrate.ts";
 import { handleRespond } from "./team-tool/respond.ts";
 import { handleStatus } from "./team-tool/status.ts";
+import { handleAnchorSet, handleAnchorClear, handleAnchorStatus, handleAnchorAccumulate } from "./team-tool/anchor.ts";
+import { handleAutoSummarizeOn, handleAutoSummarizeOff, handleAutoSummarizeStatus, handleAutoSummarizeConfig, createAutoSummarizeService } from "./team-tool/auto-summarize.ts";
 
 export { handleApi } from "./team-tool/api.ts";
 export { handleRetry } from "./team-tool/cancel.ts";
@@ -715,7 +717,12 @@ export function handleSteer(
 			true,
 		);
 	if (!task.pendingSteers) task.pendingSteers = [];
-	task.pendingSteers.push(message);
+		// HIGH-04: Cap pendingSteers array to prevent unbounded memory growth
+		const MAX_PENDING_STEERS = 100;
+		if (task.pendingSteers.length >= MAX_PENDING_STEERS) {
+			task.pendingSteers = task.pendingSteers.slice(-(MAX_PENDING_STEERS - 1));
+		}
+		task.pendingSteers.push(message);
 	saveRunTasks(loaded.manifest, loaded.tasks);
 	appendEvent(loaded.manifest.eventsPath, {
 		type: "task.steer_queued",
@@ -871,7 +878,7 @@ export async function handleTeamTool(
 	ctx: TeamContext,
 ): Promise<PiTeamsToolResult> {
 	const action = params.action ?? "list";
-	switch (action) {
+	switch (action as string) {
 		case "list":
 			return handleList(params, ctx);
 		case "get":
@@ -1157,6 +1164,41 @@ export async function handleTeamTool(
 			return handleSchedule(params, ctx);
 		case "scheduled":
 			return handleListScheduled(params, ctx);
+		case "anchor": {
+			const subAction = typeof params.config?.subAction === "string" ? params.config.subAction : "status";
+			switch (subAction) {
+				case "set":
+					return handleAnchorSet(params, ctx);
+				case "clear":
+					return handleAnchorClear(params, ctx);
+				case "accumulate":
+					return handleAnchorAccumulate(params, ctx);
+				default:
+					return handleAnchorStatus(params, ctx);
+			}
+		}
+		case "auto-summarize":
+		case "auto_boomerang": {
+			const subAction = typeof params.config?.subAction === "string" ? params.config.subAction : ((params.action as string) === "auto_boomerang" ? "toggle" : "status");
+			switch (subAction) {
+				case "on":
+					return handleAutoSummarizeOn(params, ctx);
+				case "off":
+					return handleAutoSummarizeOff(params, ctx);
+				case "config":
+					return handleAutoSummarizeConfig(params, ctx);
+				case "toggle": {
+					const service = createAutoSummarizeService();
+					service.toggle();
+					return result(
+						`Auto-summarize ${service.isEnabled() ? "enabled" : "disabled"}.`,
+						{ action: "auto-summarize", status: "ok" },
+					);
+				}
+				default:
+					return handleAutoSummarizeStatus(params, ctx);
+			}
+		}
 		case "onboard": {
 			const team = params.team ?? "default";
 			const onboarding = buildTeamOnboarding(team, ctx.cwd);

package/src/hooks/registry.ts

@@ -30,9 +30,7 @@ export async function executeHook(name: HookName, ctx: HookContext): Promise<Hoo
 	// SECURITY: If ctx contains a workspaceId, filter hooks to only those scoped to
 	// this workspace. This prevents globally-registered hooks from operating on runs
 	// they weren't designed for.
-	const scopedHooks = ctx.workspaceId
-		? hooks.filter((h) => !h.workspaceId || h.workspaceId === ctx.workspaceId)
-		: hooks;
+	const scopedHooks = hooks.filter((h) => !h.workspaceId || h.workspaceId === ctx.workspaceId);
 	if (scopedHooks.length === 0) return { hookName: name, outcome: "allow", durationMs: 0 };
 	const start = Date.now();
 	const diagnostics: string[] = [];

package/src/observability/event-bus.ts

@@ -0,0 +1,69 @@
+import type { AgentProgress } from "../runtime/progress-tracker.ts";
+
+export type CrewEventType =
+  | "agent:progress"
+  | "agent:complete"
+  | "agent:error"
+  | "run:start"
+  | "run:complete";
+
+export interface CrewEvent {
+  type: CrewEventType;
+  runId: string;
+  agentId?: string;
+  payload?: AgentProgress | string;
+  timestamp: number;
+}
+
+type CrewEventListener = (event: CrewEvent) => void;
+
+class EventBus {
+  private listeners = new Map<CrewEventType, Set<CrewEventListener>>();
+  private static _instance?: EventBus;
+
+  static getInstance(): EventBus {
+    if (!EventBus._instance) {
+      EventBus._instance = new EventBus();
+    }
+    return EventBus._instance;
+  }
+
+  /**
+   * Dispose of the EventBus instance and clear all listeners.
+   * Resets the singleton so a new instance can be created.
+   */
+  dispose(): void {
+    this.listeners.clear();
+    EventBus._instance = undefined;
+  }
+
+  emit(event: CrewEvent): void {
+    const listeners = this.listeners.get(event.type);
+    if (listeners) {
+      for (const listener of listeners) {
+        try {
+          listener(event);
+        } catch (e) {
+          console.error("[EventBus] Listener error:", e);
+        }
+      }
+    }
+  }
+
+  on(type: CrewEventType, listener: CrewEventListener): () => void {
+    if (!this.listeners.has(type)) {
+      this.listeners.set(type, new Set());
+    }
+    this.listeners.get(type)!.add(listener);
+
+    return () => {
+      this.listeners.get(type)?.delete(listener);
+    };
+  }
+
+  off(type: CrewEventType, listener: CrewEventListener): void {
+    this.listeners.get(type)?.delete(listener);
+  }
+}
+
+export const crewEventBus = EventBus.getInstance();

package/src/observability/event-to-metric.ts

@@ -32,7 +32,6 @@ export function wireEventToMetrics(events: ExtensionAPI["events"] | undefined, r
 	const retryAttemptCount = registry.counter("crew.task.retry_attempt_total", "Retry attempts by run and task");
 	const deadletterCount = registry.counter("crew.task.deadletter_total", "Deadletter triggers by reason");
 	const overflowCount = registry.counter("crew.task.overflow_phase_total", "Overflow recovery phase transitions");
-	const waitingCount = registry.counter("crew.task.waiting_total", "Tasks entering waiting state");
 	const supervisorContactCount = registry.counter("crew.task.supervisor_contact_total", "Supervisor contact requests by reason");
 	registry.gauge("crew.heartbeat.staleness_ms", "Heartbeat elapsed since last seen, milliseconds");
 	const runDuration = registry.histogram("crew.run.duration_ms", "Run end-to-end duration, milliseconds", [1000, 5000, 15000, 30000, 60000, 300000, 600000, 1800000]);
@@ -50,7 +49,6 @@ export function wireEventToMetrics(events: ExtensionAPI["events"] | undefined, r
 		["crew.task.retry_attempt", (data) => { const item = recordValue(data); taskCount.inc({ status: "retry" }); retryAttemptCount.inc({ runId: stringValue(item.runId, "unknown"), taskId: stringValue(item.taskId, "unknown") }); }],
 		["crew.task.deadletter", (data) => { const item = recordValue(data); deadletterCount.inc({ reason: stringValue(item.reason, "unknown") }); }],
 		["crew.task.overflow", (data) => { const item = recordValue(data); overflowCount.inc({ phase: stringValue(item.phase, "unknown"), previous_phase: stringValue(item.previousPhase, "none") }); }],
-		["task.waiting", (data) => { const item = recordValue(data); waitingCount.inc({ taskId: stringValue(item.taskId, "unknown"), runId: stringValue(item.runId, "unknown") }); }],
 		["supervisor.contact", (data) => { const item = recordValue(data); supervisorContactCount.inc({ reason: stringValue(item.reason, "unknown"), taskId: stringValue(item.taskId, "unknown") }); }],
 		["crew.subagent.completed", (data) => { const item = recordValue(data); subagentCount.inc({ status: stringValue(item.status, "completed") }); }],
 		["crew.subagent.failed", () => subagentCount.inc({ status: "failed" })],