pi-crew 0.9.30 → 0.9.31

package/package.json

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

package/src/extension/register.ts

@@ -139,6 +139,9 @@ export { __test__subagentSpawnParams };
 export function registerPiTeams(pi: ExtensionAPI): void {
 	const disposeI18n = initI18n(pi);
 	resetTimings();
+	// S06: Verbose/debug flags for pi-crew diagnostics
+	const verbose = process.env.PI_CREW_VERBOSE === "1" || process.argv.includes("--verbose");
+	const debug = process.env.PI_CREW_DEBUG === "1" || process.argv.includes("--debug");
 	time("register:start");
 	// Cold-start race fix (general): pre-warm the hot module graph NOW, during
 	// single-threaded registration, before any concurrent subagent can spawn.

package/src/runtime/team-runner.ts

@@ -2,13 +2,14 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentConfig } from "../agents/agent-config.ts";
 import type { CrewLimitsConfig, CrewReliabilityConfig, CrewRuntimeConfig } from "../config/config.ts";
+import { CrewError, ErrorCode } from "../errors.ts";
 import { appendHookEvent, executeHook } from "../hooks/registry.ts";
 import { childCorrelation, withCorrelation } from "../observability/correlation.ts";
 import type { MetricRegistry } from "../observability/metric-registry.ts";
 import { PluginRegistry } from "../plugins/plugin-registry.ts";
 import { NextJsPlugin, VitePlugin, VitestPlugin } from "../plugins/plugins/index.ts";
 import { writeArtifact } from "../state/artifact-store.ts";
-import { appendEvent, appendEventAsync, appendEventBuffered, flushEventLogBuffer } from "../state/event-log.ts";
+import { appendEvent, appendEventAsync, appendEventBuffered, appendEventFireAndForget, flushEventLogBuffer } from "../state/event-log.ts";
 import { HealthStore } from "../state/health-store.ts";
 import { withRunLock } from "../state/locks.ts";
 import { loadRunManifestById, saveRunManifest, saveRunManifestAsync, saveRunTasksAsync, updateRunStatus } from "../state/state-store.ts";
@@ -190,13 +191,19 @@ export function checkPerTaskBudget(
 
 function findStep(workflow: WorkflowConfig, task: TeamTaskState): WorkflowStep {
 	const step = workflow.steps.find((candidate) => candidate.id === task.stepId);
-	if (!step) throw new Error(`Workflow step '${task.stepId}' not found for task '${task.id}'.`);
+	if (!step)
+		throw new CrewError(ErrorCode.ResourceNotFound, `Workflow step '${task.stepId}' not found for task '${task.id}'.`).withContext(
+			`workflow step lookup (task=${task.id})`,
+		);
 	return step;
 }
 
 function findAgent(agents: AgentConfig[], task: TeamTaskState): AgentConfig {
 	const agent = agents.find((candidate) => candidate.name === task.agent);
-	if (!agent) throw new Error(`Agent '${task.agent}' not found for task '${task.id}'.`);
+	if (!agent)
+		throw new CrewError(ErrorCode.ResourceNotFound, `Agent '${task.agent}' not found for task '${task.id}'.`).withContext(
+			`agent lookup (task=${task.id})`,
+		);
 	return agent;
 }
 
@@ -1301,7 +1308,9 @@ async function executeTeamRunCore(
 						};
 						if (failed) {
 							lastFailed = enriched;
-							throw new Error(failed.error ?? `Task ${task.id} failed.`);
+							throw new CrewError(ErrorCode.TaskNotFound, failed.error ?? `Task ${task.id} failed.`).withContext(
+								`retry evaluation (run=${manifest.runId})`,
+							);
 						}
 						input.metricRegistry?.histogram("crew.task.retry_count", "Retries per task", [0, 1, 2, 3, 5, 10]).observe(
 							{
@@ -1652,6 +1661,29 @@ async function executeTeamRunCore(
 	const waiting = tasks.find((task) => task.status === "waiting");
 	const running = tasks.find((task) => task.status === "running");
 	manifest = applyPolicy(manifest, tasks, input.limits);
+
+	// S02: Verify workflow-declared output files exist before marking completed
+	if (input.workflow?.steps) {
+		const missingOutputs: string[] = [];
+		for (const step of input.workflow.steps) {
+			if (step.output && typeof step.output === "string") {
+				const outputPath = path.join(manifest.artifactsRoot, step.output);
+				if (!fs.existsSync(outputPath)) {
+					missingOutputs.push(step.output);
+				}
+			}
+		}
+		if (missingOutputs.length > 0) {
+			// Emit warning event — run still completes normally to avoid hanging
+			appendEventFireAndForget(manifest.eventsPath, {
+				type: "run.deliverable_warning",
+				runId: manifest.runId,
+				message: `Missing workflow output files: ${missingOutputs.join(", ")}`,
+				data: { missingFiles: missingOutputs },
+			});
+		}
+	}
+
 	const effectiveness = evaluateRunEffectiveness({
 		manifest,
 		tasks,

package/src/state/state-store.ts

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import * as fsp from "node:fs/promises";
 import * as path from "node:path";
 import { DEFAULT_CACHE, DEFAULT_PATHS } from "../config/defaults.ts";
 import { errors } from "../errors.ts";
@@ -83,7 +84,7 @@ function genOf(stateRoot: string): number {
 	return manifestCacheGeneration.get(stateRoot) ?? 0;
 }
 
-const MANIFEST_CACHE_TTL_MS = 15 * 1000; // 15 seconds (FIX: increased from 5s for read-heavy workloads; 5s was too short causing unnecessary cache invalidation)
+const MANIFEST_CACHE_TTL_MS = 60 * 1000; // 60 seconds (FIX: increased from 15s for read-heavy workloads; render tick 160ms caused frequent misses)
 const LOAD_MANIFEST_RETRY_LIMIT = 5; // Configurable retry limit for mtime/size stability checks under contention
 const manifestCache = new Map<string, ManifestCacheEntry>();
 
@@ -475,7 +476,7 @@ export async function saveRunTasksAsync(manifest: TeamRunManifest, tasks: TeamTa
 	// FIX: Invalidate cache BEFORE atomic write to prevent stale cache serving.
 	invalidateRunCache(manifest.stateRoot);
 	try {
-		fs.statSync(manifest.stateRoot);
+		await fsp.access(manifest.stateRoot);
 	} catch {
 		return;
 	}
@@ -800,7 +801,12 @@ export async function loadRunManifestByIdAsync(
 		} else if (!validateRunManifestPaths(cwd, runId, cached.manifest, stateRoot, tasksPath)) {
 			manifestCache.delete(stateRoot);
 			return undefined;
-		} else if (!fs.existsSync(tasksPath)) {
+		} else if (
+			!(await fsp.access(tasksPath).then(
+				() => true,
+				() => false,
+			))
+		) {
 			// Tasks file was deleted after cache was populated — do not serve stale cache.
 			manifestCache.delete(stateRoot);
 			return undefined;

package/src/ui/run-dashboard.ts

@@ -28,6 +28,17 @@ import { applyStatusColor, colorizeStatusGlyphs, iconForStatus, type RunStatus }
 import type { CrewTheme } from "./theme-adapter.ts";
 import { asCrewTheme, subscribeThemeChange } from "./theme-adapter.ts";
 
+/** S05 — wrap a pane render in try/catch so a single pane crash does not bring down the whole dashboard. */
+function safeRenderPane(name: string, fn: () => string[]): string[] {
+	try {
+		return fn();
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		logInternalError("run-dashboard", new Error(`Dashboard pane '${name}' render failed: ${message}`));
+		return [`<error: ${name}>`];
+	}
+}
+
 interface DashboardComponent {
 	invalidate(): void;
 	render(width: number): string[];
@@ -615,20 +626,24 @@ export class RunDashboard implements DashboardComponent {
 						// Pane content (max 8 lines) — F-2: colorize embedded status glyphs.
 						const paneLines = snap
 							? this.activePane === "agents"
-								? renderAgentsPane(snap, this.options)
+								? safeRenderPane("agents", () => renderAgentsPane(snap, this.options))
 								: this.activePane === "progress"
-									? renderProgressPane(snap)
+									? safeRenderPane("progress", () => renderProgressPane(snap))
 									: this.activePane === "mailbox"
-										? renderMailboxPane(snap)
+										? safeRenderPane("mailbox", () => renderMailboxPane(snap))
 										: this.activePane === "health"
-											? renderHealthPane(snap, {
-													isForeground: !r.async,
-												})
+											? safeRenderPane("health", () =>
+													renderHealthPane(snap, {
+														isForeground: !r.async,
+													}),
+												)
 											: this.activePane === "metrics"
-												? renderMetricsPane(snap, {
-														registry: this.options.registry,
-													})
-												: renderTranscriptPane(snap)
+												? safeRenderPane("metrics", () =>
+														renderMetricsPane(snap, {
+															registry: this.options.registry,
+														}),
+													)
+												: safeRenderPane("transcript", () => renderTranscriptPane(snap))
 							: [...readAgentPreview(r, 4, this.options), ...readProgressPreview(r, 2)];
 						const filteredPane = paneLines.filter((l) => l && !l.includes("(none)") && l.trim() !== "");
 						if (filteredPane.length > 0) {

package/src/workflows/cost-estimator.ts

@@ -0,0 +1,34 @@
+import type { WorkflowConfig } from "./workflow-config.ts";
+
+// Rough token estimates per role (input + output combined)
+const ROLE_TOKEN_ESTIMATES: Record<string, number> = {
+	explorer: 15000,
+	planner: 20000,
+	executor: 25000,
+	reviewer: 12000,
+	"security-reviewer": 12000,
+	"test-engineer": 15000,
+	analyst: 18000,
+	writer: 15000,
+	verifier: 10000,
+	critic: 12000,
+};
+
+// Rough cost per 1K tokens (USD) — using a mid-range model price
+const COST_PER_1K_TOKENS = 0.003;
+
+export interface CostEstimate {
+	totalTokens: number;
+	estimatedCostUSD: number;
+	perStep: Array<{ stepId: string; role: string; tokens: number }>;
+}
+
+export function estimateWorkflowCost(workflow: WorkflowConfig): CostEstimate {
+	const perStep = workflow.steps.map((step) => {
+		const tokens = ROLE_TOKEN_ESTIMATES[step.role] ?? 15000; // default 15K
+		return { stepId: step.id, role: step.role, tokens };
+	});
+	const totalTokens = perStep.reduce((sum, s) => sum + s.tokens, 0);
+	const estimatedCostUSD = (totalTokens / 1000) * COST_PER_1K_TOKENS;
+	return { totalTokens, estimatedCostUSD, perStep };
+}

package/src/workflows/validate-workflow.ts

@@ -18,6 +18,16 @@ export function validateWorkflowForTeam(workflow: WorkflowConfig, team: TeamConf
 		}
 	}
 
+	// Validate output field types
+	for (const step of workflow.steps) {
+		if (step.output !== undefined && step.output !== false && typeof step.output !== "string") {
+			errors.push(`Step '${step.id}' has invalid 'output' field: expected string or false, got ${typeof step.output}.`);
+		}
+		if (typeof step.output === "string" && step.output.trim() === "") {
+			errors.push(`Step '${step.id}' has empty 'output' string.`);
+		}
+	}
+
 	const visiting = new Set<string>();
 	const visited = new Set<string>();
 	const byId = new Map(workflow.steps.map((step) => [step.id, step]));