pi-crew 0.5.2 → 0.5.5

package/src/state/event-log.ts

@@ -63,12 +63,17 @@ let appendCounter = 0;
 
 /** Simple cross-process lock for an eventsPath to prevent JSONL interleave on concurrent append.
  *  Detects stale locks by checking the owner PID written inside the lock directory.
+ *
+ *  @deprecated Prefer `appendEventAsync()` for callers in async contexts. The sync lock
+ *  uses `sleepSync` which blocks the event loop and prevents AbortSignal handlers from firing.
  */
 export function withEventLogLockSync<T>(eventsPath: string, fn: () => T): T {
+	// Ensure parent directory exists before attempting lock
+	fs.mkdirSync(path.dirname(eventsPath), { recursive: true });
 	const lockDir = `${eventsPath}.lock`;
 	const pidFile = path.join(lockDir, "pid");
 	const start = Date.now();
-	const timeout = 5000;
+	const timeout = 120000; // 120s timeout for slow CI environments
 	const staleMs = 10000;
 	let acquired = false;
 	while (true) {
@@ -79,6 +84,8 @@ export function withEventLogLockSync<T>(eventsPath: string, fn: () => T): T {
 			break;
 		} catch {
 			if (Date.now() - start > timeout) {
+				// Log error and continue without lock — lock is held by live process.
+				// Stale detection will clean up dead locks on next attempt.
 				logInternalError("event-log.lock-timeout", new Error(`Event log lock timeout for ${eventsPath}`), `lockDir=${lockDir}`);
 				break;
 			}
@@ -112,9 +119,15 @@ export function withEventLogLockSync<T>(eventsPath: string, fn: () => T): T {
 	}
 }
 
-function evictOldestSequenceCacheEntry(): void {
-	const first = sequenceCache.keys().next().value;
-	if (first !== undefined) sequenceCache.delete(first);
+function evictOldestSequenceCacheEntries(): void {
+	// Batch evict oldest 50% of entries when cache is full
+	const toEvict = Math.ceil(MAX_SEQUENCE_CACHE_ENTRIES / 2);
+	let evicted = 0;
+	for (const key of sequenceCache.keys()) {
+		if (evicted >= toEvict) break;
+		sequenceCache.delete(key);
+		evicted++;
+	}
 }
 
 export function sequencePath(eventsPath: string): string {
@@ -174,10 +187,116 @@ export function computeEventFingerprint(event: Pick<TeamEvent, "type" | "runId"
 	return createHash("sha256").update(JSON.stringify({ type: event.type, runId: event.runId, taskId: event.taskId, data: event.data ?? null })).digest("hex").slice(0, 16);
 }
 
+/**
+ * @deprecated Prefer `appendEventAsync()` in async contexts. The sync lock uses
+ * `sleepSync` which blocks the Node.js event loop, preventing AbortSignal handlers
+ * from firing and degrading live-agent responsiveness.
+ */
 export function appendEvent(eventsPath: string, event: AppendTeamEvent): TeamEvent {
 	return withEventLogLockSync(eventsPath, () => appendEventInsideLock(eventsPath, event));
 }
 
+// --- Async write queue (non-blocking alternative to withEventLogLockSync) ---
+const asyncQueues = new Map<string, Promise<unknown>>();
+
+/**
+ * Append an event to the event log using non-blocking async I/O.
+ *
+ * Uses a per-eventsPath promise-chain queue to ensure sequential writes without
+ * blocking the Node.js event loop. This allows AbortSignal handlers and other
+ * async operations to proceed while events are being persisted.
+ *
+ * For callers that are already in an async context (team-runner, task-runner,
+ * foreground-control, etc.), prefer this over the sync `appendEvent()`.
+ */
+export async function appendEventAsync(eventsPath: string, event: AppendTeamEvent): Promise<TeamEvent> {
+	const queueKey = eventsPath;
+	const prev = asyncQueues.get(queueKey) ?? Promise.resolve();
+	const next = prev.then(async (): Promise<TeamEvent> => {
+		// Ensure directory exists
+		await fs.promises.mkdir(path.dirname(eventsPath), { recursive: true });
+
+		// Build metadata (same logic as appendEventInsideLock)
+		const baseMetadata = event.metadata;
+		let metadata: TeamEventMetadata = {
+			seq: baseMetadata?.seq ?? nextSequence(eventsPath),
+			provenance: baseMetadata?.provenance ?? "team_runner",
+			...(baseMetadata?.parentEventId ? { parentEventId: baseMetadata.parentEventId } : {}),
+			...(baseMetadata?.attemptId ? { attemptId: baseMetadata.attemptId } : {}),
+			...(baseMetadata?.branchId ? { branchId: baseMetadata.branchId } : {}),
+			...(baseMetadata?.causationId ? { causationId: baseMetadata.causationId } : {}),
+			...(baseMetadata?.correlationId ? { correlationId: baseMetadata.correlationId } : {}),
+			...(baseMetadata?.sessionIdentity ? { sessionIdentity: baseMetadata.sessionIdentity } : {}),
+			...(baseMetadata?.ownership ? { ownership: baseMetadata.ownership } : {}),
+			...(baseMetadata?.nudgeId ? { nudgeId: baseMetadata.nudgeId } : {}),
+			...(baseMetadata?.confidence ? { confidence: baseMetadata.confidence } : {}),
+		};
+		const fullEvent: TeamEvent = {
+			time: new Date().toISOString(),
+			...event,
+			metadata,
+		};
+		if (baseMetadata?.fingerprint || TERMINAL_EVENT_TYPES.has(fullEvent.type)) {
+			metadata = { ...metadata, fingerprint: baseMetadata?.fingerprint ?? computeEventFingerprint(fullEvent) };
+			fullEvent.metadata = metadata;
+		}
+
+		// Overflow handling: same logic as sync path
+		const isTerminal = TERMINAL_EVENT_TYPES.has(fullEvent.type);
+		let skippedDueToSize = false;
+		if (!isTerminal && fs.existsSync(eventsPath)) {
+			const stat = fs.statSync(eventsPath);
+			if (stat.size > MAX_EVENTS_BYTES) {
+				try {
+					compactEventLog(eventsPath);
+				} catch (error) {
+					logInternalError("event-log.immediate-compact", error, `eventsPath=${eventsPath}`);
+				}
+				if (fs.existsSync(eventsPath)) {
+					const afterCompact = fs.statSync(eventsPath);
+					if (afterCompact.size > MAX_EVENTS_BYTES) {
+						rotateEventLog(eventsPath);
+					}
+				}
+			}
+		}
+		try {
+			if (fs.existsSync(eventsPath) && fs.statSync(eventsPath).size > MAX_EVENTS_BYTES) {
+				logInternalError("event-log.size-limit", new Error(`events file ${eventsPath} exceeds ${MAX_EVENTS_BYTES} bytes after compaction`), `eventsPath=${eventsPath}`);
+				skippedDueToSize = true;
+			}
+		} catch (error) {
+			logInternalError("event-log.size-check", error, `eventsPath=${eventsPath}`);
+		}
+
+		if (!skippedDueToSize) {
+			const line = JSON.stringify(redactSecrets(fullEvent)) + "\n";
+			await fs.promises.appendFile(eventsPath, line, { encoding: "utf-8" });
+		}
+
+		appendCounter++;
+		if (appendCounter % 100 === 0 && needsRotation(eventsPath)) {
+			try { compactEventLog(eventsPath); } catch (error) { logInternalError("event-log.rotation", error, `eventsPath=${eventsPath}`); }
+		}
+		try { emitFromTeamEvent(fullEvent); } catch (error) { logInternalError("event-log.emit", error); }
+
+		const seq = fullEvent.metadata?.seq ?? 0;
+		try {
+			const stat = fs.statSync(eventsPath);
+			if (sequenceCache.size >= MAX_SEQUENCE_CACHE_ENTRIES) {
+				evictOldestSequenceCacheEntries();
+			}
+			sequenceCache.set(eventsPath, { size: stat.size, mtimeMs: stat.mtimeMs, seq });
+			persistSequence(eventsPath, seq);
+		} catch (error) {
+			logInternalError("event-log.persist-sequence", error, `eventsPath=${eventsPath}`);
+		}
+		return fullEvent;
+	});
+	asyncQueues.set(queueKey, next.catch(() => {}));
+	return next;
+}
+
 /**
  * Body of `appendEvent` assuming the caller already holds
  * `withEventLogLockSync` for `eventsPath`. Used by `appendEventBuffered` to
@@ -254,7 +373,7 @@ function appendEventInsideLock(eventsPath: string, event: AppendTeamEvent): Team
 	try {
 		const stat = fs.statSync(eventsPath);
 		if (sequenceCache.size >= MAX_SEQUENCE_CACHE_ENTRIES) {
-			evictOldestSequenceCacheEntry();
+			evictOldestSequenceCacheEntries();
 		}
 		sequenceCache.set(eventsPath, { size: stat.size, mtimeMs: stat.mtimeMs, seq });
 		persistSequence(eventsPath, seq);
@@ -283,6 +402,12 @@ const bufferedTimers = new Map<string, ReturnType<typeof setTimeout>>();
 const DEFAULT_BUFFER_MS = 20;
 
 export function appendEventBuffered(eventsPath: string, event: AppendTeamEvent, bufferMs = DEFAULT_BUFFER_MS): Promise<TeamEvent> {
+	// FIX: Terminal events must bypass buffer to ensure they're written immediately.
+	// Previously, terminal events like task.failed could be lost on process crash.
+	if (TERMINAL_EVENT_TYPES.has(event.type)) {
+		// For terminal events, write synchronously to ensure durability
+		return Promise.resolve(appendEvent(eventsPath, event));
+	}
 	return new Promise<TeamEvent>((resolve, reject) => {
 		const queue = bufferedQueues.get(eventsPath) ?? [];
 		queue.push({ event, resolve, reject });
@@ -325,12 +450,13 @@ export function flushEventLogBuffer(): void {
 }
 
 /**
- * 2.2 caller-migration helper — schedule a buffered append but do not return
- * the resulting Promise. Use only for events whose return value is ignored
- * (high-frequency `task.progress`). Errors are logged via logInternalError.
+ * Schedule an async event append without waiting for the result.
+ * Uses the non-blocking async queue to avoid blocking the event loop.
+ * Use only for events whose return value is ignored (high-frequency `task.progress`).
+ * Errors are logged via logInternalError.
  */
-export function appendEventFireAndForget(eventsPath: string, event: AppendTeamEvent, bufferMs = DEFAULT_BUFFER_MS): void {
-	appendEventBuffered(eventsPath, event, bufferMs).catch((error) => logInternalError("event-log.fire-and-forget", error, eventsPath));
+export function appendEventFireAndForget(eventsPath: string, event: AppendTeamEvent, _bufferMs = DEFAULT_BUFFER_MS): void {
+	appendEventAsync(eventsPath, event).catch((error) => logInternalError("event-log.fire-and-forget", error, eventsPath));
 }
 
 // Auto-flush on process exit so buffered events do not silently leak.

package/src/state/hook-instinct-bridge.ts

@@ -6,13 +6,13 @@
 import { crewHooks } from "../runtime/crew-hooks.ts";
 
 // Lazy-initialized store and paths
-let storeInstance: import("./instinct-store").InstinctStore | null = null;
-let pathsInstance: typeof import("../utils/paths") | null = null;
+let storeInstance: import("./instinct-store.js").InstinctStore | null = null;
+let pathsInstance: typeof import("../utils/paths.js") | null = null;
 
 async function getStore() {
 	if (!storeInstance) {
-		const { InstinctStore } = await import("./instinct-store");
-		const paths = await import("../utils/paths");
+		const { InstinctStore } = await import("./instinct-store.js");
+		const paths = await import("../utils/paths.js");
 		storeInstance = new InstinctStore(paths.projectCrewRoot(process.cwd()));
 	}
 	return storeInstance;
@@ -20,7 +20,7 @@ async function getStore() {
 
 async function getPaths() {
 	if (!pathsInstance) {
-		pathsInstance = await import("../utils/paths");
+		pathsInstance = await import("../utils/paths.js");
 	}
 	return pathsInstance;
 }

package/src/state/state-store.ts

@@ -12,6 +12,7 @@ import { assertSafePathId, resolveContainedRelativePath, resolveRealContainedPat
 import { withRunLock } from "./locks.ts";
 import type { TeamConfig } from "../teams/team-config.ts";
 import type { WorkflowConfig } from "../workflows/workflow-config.ts";
+import { toPiSessionId } from "../utils/session-utils.ts";
 
 export interface RunPaths {
 	runId: string;
@@ -32,7 +33,7 @@ interface ManifestCacheEntry {
 	cachedAt?: number;
 }
 
-const MANIFEST_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+const MANIFEST_CACHE_TTL_MS = 30 * 1000; // 30 seconds (FIX: reduced from 5 minutes for faster state updates)
 const manifestCache = new Map<string, ManifestCacheEntry>();
 
 function setManifestCache(stateRoot: string, entry: ManifestCacheEntry): void {
@@ -148,6 +149,7 @@ export function createRunManifest(params: {
 	const manifest: TeamRunManifest = {
 		schemaVersion: 1,
 		runId: paths.runId,
+		sessionId: toPiSessionId(paths.runId),
 		team: params.team.name,
 		workflow: params.workflow?.name,
 		goal: params.goal,

package/src/state/types.ts

@@ -4,6 +4,7 @@ import type { WorkerHeartbeatState } from "../runtime/worker-heartbeat.ts";
 import type { CrewAgentProgress } from "../runtime/crew-agent-runtime.ts";
 import type { RolloutEntry, CoherenceMark } from "./decision-ledger.ts";
 export type { RolloutEntry, CoherenceMark };
+export type { CrewAgentProgress };
 
 export type { TeamRunStatus, TeamTaskStatus } from "./contracts.ts";
 
@@ -25,6 +26,7 @@ export interface VerificationCommandResult {
 	cmd: string;
 	status: "passed" | "failed" | "not_run";
 	exitCode?: number | null;
+	durationMs?: number;
 	outputArtifact?: ArtifactDescriptor;
 }
 
@@ -156,6 +158,8 @@ export interface CrewAttentionEventData {
 export interface TeamRunManifest {
 	schemaVersion: 1;
 	runId: string;
+	/** pi session ID aligned with run ID for cross-referencing (e.g., "crew-team20260528") */
+	sessionId?: string;
 	team: string;
 	workflow?: string;
 	goal: string;

package/src/types/new-api-types.ts

@@ -0,0 +1,34 @@
+/**
+ * Type imports from pi v0.77.0
+ */
+import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
+
+export type {
+  AgentSessionEvent,
+} from "@earendil-works/pi-coding-agent";
+
+// Note: AgentEvent is not exported by pi-coding-agent v0.77.0
+// Using AgentEndEvent and AgentStartEvent instead
+
+// Type guards for pi-crew usage
+export function isToolEvent(event: AgentSessionEvent): boolean {
+  return event.type === "tool_execution_start" || 
+         event.type === "tool_execution_update" || 
+         event.type === "tool_execution_end";
+}
+
+export function isAgentLifecycleEvent(event: AgentSessionEvent): boolean {
+  return event.type === "agent_start" || event.type === "agent_end";
+}
+
+export function isCompactionEvent(event: AgentSessionEvent): boolean {
+  return event.type === "compaction_start" || event.type === "compaction_end";
+}
+
+export function isRetryEvent(event: AgentSessionEvent): boolean {
+  return event.type === "auto_retry_start" || event.type === "auto_retry_end";
+}
+
+export function isQueueEvent(event: AgentSessionEvent): boolean {
+  return event.type === "queue_update";
+}

package/src/ui/agent-management-overlay.ts

@@ -38,6 +38,8 @@ function sourceIcon(source: ResourceSource): string {
 		case "user": return "👤";
 		case "project": return "📂";
 		case "git": return "🔗";
+		case "dynamic": return "⚡";
+		default: return "❓";
 	}
 }
 
@@ -47,6 +49,8 @@ function sourceLabel(source: ResourceSource): string {
 		case "user": return "user";
 		case "project": return "project";
 		case "git": return "git";
+		case "dynamic": return "dynamic";
+		default: return "unknown";
 	}
 }
 
@@ -61,7 +65,7 @@ export interface AgentOverlayState {
 export function createAgentOverlayState(entries: AgentEntry[], maxVisible = 20): AgentOverlayState {
 	return {
 		entries: entries.sort((a, b) => {
-			const order: Record<ResourceSource, number> = { project: 0, user: 1, git: 2, builtin: 3 };
+			const order: Record<ResourceSource, number> = { project: 0, user: 1, git: 2, builtin: 3, dynamic: 4 };
 			const diff = (order[a.source] ?? 4) - (order[b.source] ?? 4);
 			return diff !== 0 ? diff : a.name.localeCompare(b.name);
 		}),

package/src/ui/crew-widget.ts

@@ -23,14 +23,25 @@ import { SUBAGENT_SPINNER_FRAMES, spinnerBucket, spinnerFrame } from "./spinner.
 
 const SPINNER = SUBAGENT_SPINNER_FRAMES;
 const TOOL_LABELS: Record<string, string> = {
-	read: "reading",
+	head: "reading",
 	bash: "running command",
 	edit: "editing",
 	write: "writing",
-	grep: "searching",
+grep: "searching",
 	find: "finding files",
 	ls: "listing",
 };
+
+const TOOL_ICONS: Record<string, string> = {
+	read: "📖",
+	bash: ">",
+	edit: "✏",
+	write: "📝",
+	grep: "🔍",
+	find: "📁",
+	ls: "📋",
+	agent: "🤖",
+};
 const LEGACY_WIDGET_KEY = "pi-crew";
 const WIDGET_KEY = "pi-crew-active";
 const STATUS_KEY = "pi-crew";
@@ -90,16 +101,16 @@ function describeLiveActivity(handle: LiveAgentHandle): string {
 	if (act.activeTools.size > 0) {
 		const groups = new Map<string, number>();
 		for (const toolName of act.activeTools.values()) {
-			const label = TOOL_LABELS[toolName] ?? toolName;
-			groups.set(label, (groups.get(label) ?? 0) + 1);
+			groups.set(toolName, (groups.get(toolName) ?? 0) + 1);
 		}
 		const parts: string[] = [];
-		for (const [label, count] of groups) {
+		for (const [toolName, count] of groups) {
+			const icon = TOOL_ICONS[toolName] ?? "?";
+			const label = TOOL_LABELS[toolName] ?? toolName;
 			if (count > 1) {
-				const noun = label === "searching" ? "patterns" : label === "listing" ? "entries" : "files";
-				parts.push(`${label} ${count} ${noun}`);
+				parts.push(`${icon}${count} ${label}s`);
 			} else {
-				parts.push(label);
+				parts.push(`${icon} ${label}`);
 			}
 		}
 		return parts.join(", ") + "…";
@@ -241,14 +252,17 @@ export function activeWidgetRuns(cwd: string, manifestCache?: ManifestCache, sna
 function statusSummary(runs: WidgetRun[]): string {
 	const agents = runs.flatMap((item) => item.agents);
 	const runningAgents = agents.filter((agent) => agent.status === "running").length;
-	const queuedAgents = agents.filter((agent) => agent.status === "queued").length;
-	const waitingAgents = agents.filter((agent) => agent.status === "waiting").length;
+	const queuedAgents = agents.filter((agent) => agent.status === "queued" || agent.status === "waiting").length;
 	const completedAgents = agents.filter((agent) => agent.status === "completed").length;
-	const parts = [`${runningAgents} running`];
-	if (queuedAgents) parts.push(`${queuedAgents} queued`);
-	if (waitingAgents) parts.push(`${waitingAgents} waiting`);
-	if (completedAgents) parts.push(`${completedAgents}/${agents.length} done`);
-	return `Crew: ${parts.join(", ")}`;
+	const totalAgents = agents.length;
+	const totalRuns = runs.length;
+	const model = agents.find((a) => a.model)?.model?.split("/").at(-1);
+	const parts = [`⚙ ${runningAgents}r`];
+	if (queuedAgents > 0) parts.push(`${queuedAgents}q`);
+	if (completedAgents > 0) parts.push(`${completedAgents}/${totalAgents}done`);
+	if (totalRuns > 1) parts.push(`${totalRuns}runs`);
+	if (model) parts.push(model);
+	return parts.join(" · ");
 }
 
 export function notificationBadge(count: number | undefined, env: NodeJS.ProcessEnv = process.env): string {

package/src/ui/powerbar-publisher.ts

@@ -12,6 +12,8 @@ import type { ManifestCache } from "../runtime/manifest-cache.ts";
 import type { RunSnapshotCache, RunUiSnapshot } from "./snapshot-types.ts";
 import { notificationBadge } from "./crew-widget.ts";
 import { RenderCoalescer } from "./render-coalescer.ts";
+import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
+import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
 
 type EventBus = { emit?: (event: string, data: unknown) => void; listenerCount?: (event: string) => number } | undefined;
 type StatusContext = { hasUI?: boolean; ui?: { setStatus?: (key: string, text: string | undefined) => void } } | undefined;
@@ -63,6 +65,7 @@ export function registerPiCrewPowerbarSegments(events: EventBus, config?: CrewUi
 	if (config?.powerbar === false) return;
 	safeEmit(events, "powerbar:register-segment", { id: "pi-crew-active", label: "pi-crew active agents" });
 	safeEmit(events, "powerbar:register-segment", { id: "pi-crew-progress", label: "pi-crew run progress" });
+	safeEmit(events, "powerbar:register-segment", { id: "pi-crew-steps", label: "pi-crew workflow steps" });
 }
 
 export function updatePiCrewPowerbar(events: EventBus, cwd: string, config?: CrewUiConfig, manifestCache?: ManifestCache, snapshotCache?: RunSnapshotCache, ctx?: StatusContext, notificationCount = 0, preloadedManifests?: TeamRunManifest[]): void {
@@ -90,9 +93,10 @@ export function updatePiCrewPowerbar(events: EventBus, cwd: string, config?: Cre
 	if (!active.length) {
 		lastActiveKey = undefined;
 		lastProgressKey = undefined;
+		lastStepsKey = undefined;
 		safeEmit(events, "powerbar:update", { id: "pi-crew-active" });
 		safeEmit(events, "powerbar:update", { id: "pi-crew-progress" });
-		if (useStatusFallback) setStatusFallback(ctx, undefined);
+		safeEmit(events, "powerbar:update", { id: "pi-crew-steps" });
 		return;
 	}
 	const agents = active.flatMap((item) => item.agents);
@@ -108,13 +112,33 @@ export function updatePiCrewPowerbar(events: EventBus, cwd: string, config?: Cre
 	const model = config?.showModel === false ? undefined : agents.find((agent) => agent.model)?.model?.split("/").at(-1);
 	const tokenText = config?.showTokens === false || !tokenTotal ? undefined : compactTokens(tokenTotal);
 	const liveRunning = listLiveAgents().filter((a) => a.status === "running").length;
-	const activeText = `crew ${running}a/${waiting}w${liveRunning > 0 ? `/${liveRunning}live` : ""}${notificationBadge(notificationCount)}`;
-	const activeSuffix = [model, tokenText].filter(Boolean).join(" · ") || undefined;
+	// Always show consistent status: running count + queued count from live tasks only
+	// Avoid snapshot cache for counts to prevent UI jumping
+	const runningCount = agents.filter((a) => a.status === "running").length;
+	// Count queued/waiting tasks directly from tasks array (not snapshot) for consistency
+	const queuedCount = active.reduce((sum, item) => sum + item.tasks.reduce((s, t) => s + (t.status === "queued" || t.status === "waiting" ? 1 : 0), 0), 0);
+	// Format: "1 running", "2 running · 1 queued", "3 queued", "idle"
+	const runningLabel = runningCount === 1 ? "1 running" : `${runningCount} running`;
+	const queuedLabel = queuedCount === 1 ? "1 queued" : `${queuedCount} queued`;
+	const crewStatus = runningCount > 0 && queuedCount > 0 ? `${runningLabel} · ${queuedLabel}` : runningCount > 0 ? runningLabel : queuedCount > 0 ? queuedLabel : "idle";
+	const liveSuffix = liveRunning > 0 ? ` (${liveRunning} live)` : "";
+	const notificationText = notificationBadge(notificationCount);
+	// Always show model + tokens as suffix when available (for activePayload consistency)
+	const suffixParts = [model, tokenText].filter(Boolean);
+	const activeSuffix = suffixParts.length > 0 ? suffixParts.join(" · ") : undefined;
+	// Progress always includes token count for consistency
 	const progressSuffix = `${completed}/${total}${tokenText ? ` · ${tokenText}` : ""}`;
+	// Build complete, always-consistent fallback text AND event payload to prevent UI flickering
+	// Both fallback and events must use the SAME format - no conditional display
+	// Format: "⚙ 1 running · 1 queued · model · 30k · 0/1" (never changes based on availability)
+	const progressPart = `${completed}/${total}`;
+	const allParts = [`⚙ ${crewStatus}`, model ?? "", tokenText ?? "", progressPart].filter(Boolean);
+	const unifiedText = allParts.join(" · ");
+	// activePayload.text includes notification badge for event payload
 	const activePayload = {
 		id: "pi-crew-active",
 		icon: "⚙",
-		text: activeText,
+		text: `⚙ ${crewStatus}${liveSuffix}${notificationText}${activeSuffix ? ` · ${activeSuffix}` : ""}`,
 		suffix: activeSuffix,
 		color: running ? "accent" : "warning",
 	} as const;
@@ -126,12 +150,15 @@ export function updatePiCrewPowerbar(events: EventBus, cwd: string, config?: Cre
 		color: completed === total ? "success" : "accent",
 		barSegments: 8,
 	} as const;
+	// Build step progress: "explorer > planner > executor > verifier" with current step highlighted
+	const stepsPayload = buildStepsPayload(active, tasks);
 	// 1.8: dedup per segment using a key over every visible field. Previously
 	// the dedup string only carried text/suffix/running, so changes to `bar`
 	// (progress %) or `color` could be swallowed and stale UI emitted again
 	// later as a single noisy burst.
 	const activeKey = powerbarKey(activePayload);
 	const progressKey = powerbarKey(progressPayload);
+	const stepsKey = powerbarKey(stepsPayload);
 	if (activeKey !== lastActiveKey) {
 		lastActiveKey = activeKey;
 		safeEmit(events, "powerbar:update", activePayload);
@@ -140,14 +167,21 @@ export function updatePiCrewPowerbar(events: EventBus, cwd: string, config?: Cre
 		lastProgressKey = progressKey;
 		safeEmit(events, "powerbar:update", progressPayload);
 	}
-	if (useStatusFallback) setStatusFallback(ctx, `${activeText}${activeSuffix ? ` · ${activeSuffix}` : ""} · ${progressSuffix}`);
+	if (stepsKey !== lastStepsKey) {
+		lastStepsKey = stepsKey;
+		safeEmit(events, "powerbar:update", stepsPayload);
+	}
+	// Never call setStatusFallback - crew-widget manages "pi-crew" status with its own widget format
+	// Powerbar only emits events; it does not set status directly
 }
 
 // --- Dedup state: skip emit if segment data unchanged ---
 let lastActiveKey: string | undefined;
 let lastProgressKey: string | undefined;
+let lastStepsKey: string | undefined;
 
 interface PowerbarPayloadShape {
+	id?: string;
 	text?: string;
 	suffix?: string;
 	bar?: number;
@@ -160,6 +194,63 @@ function powerbarKey(payload: PowerbarPayloadShape): string {
 	return `${payload.text ?? ""}|${payload.suffix ?? ""}|${payload.bar ?? ""}|${payload.color ?? ""}|${payload.icon ?? ""}|${payload.barSegments ?? ""}`;
 }
 
+interface ActiveItem {
+	run: TeamRunManifest;
+	agents: ReturnType<typeof readCrewAgents>;
+	tasks: TeamTaskState[];
+	snapshot?: RunUiSnapshot;
+}
+
+/**
+ * Build the workflow steps segment showing: ✓explore › →plan › ○execute › ○verify
+ * with the current/active step highlighted using → arrow.
+ */
+function buildStepsPayload(active: ActiveItem[], allTasks: TeamTaskState[]): PowerbarPayloadShape {
+	if (!active.length) {
+		return { id: "pi-crew-steps" };
+	}
+	const run = active[0]!.run;
+	const workflowName = run.workflow ?? "default";
+	// Load workflow steps
+	const workflows = allWorkflows(discoverWorkflows(run.cwd));
+	const workflow = workflows.find((w) => w.name === workflowName);
+	if (!workflow || workflow.steps.length === 0) {
+		return { id: "pi-crew-steps", text: workflowName };
+	}
+	// Build step status map from tasks
+	const stepStatus = new Map<string, "completed" | "running" | "pending">();
+	for (const task of allTasks) {
+		if (!task.stepId) continue;
+		if (!stepStatus.has(task.stepId)) {
+			if (task.status === "completed") {
+				stepStatus.set(task.stepId, "completed");
+			} else if (task.status === "running" || task.status === "queued" || task.status === "waiting") {
+				stepStatus.set(task.stepId, "running");
+			}
+		}
+	}
+	// Format: "✓explore › →plan › ○execute › ○verify"
+	// ✓ = completed, → = running (current), ○ = pending
+	const stepParts: string[] = [];
+	for (const step of workflow.steps) {
+		const status = stepStatus.get(step.id) ?? "pending";
+		const icon = status === "completed" ? "✓" : status === "running" ? "→" : "○";
+		// Shorten long step names
+		const stepName = step.id.length > 10 ? step.id.slice(0, 9) + "…" : step.id;
+		stepParts.push(`${icon}${stepName}`);
+	}
+	const stepsText = stepParts.join(" › ");
+	// Color: accent if running step exists, success if all complete, dim otherwise
+	const hasRunningStep = [...stepStatus.values()].includes("running");
+	const allComplete = stepStatus.size === workflow.steps.length && ![...stepStatus.values()].includes("running");
+	const color = allComplete ? "success" : hasRunningStep ? "accent" : "dim";
+	return {
+		id: "pi-crew-steps",
+		text: stepsText,
+		color,
+	};
+}
+
 // --- Coalesced powerbar update ---
 
 interface PowerbarUpdateArgs {
@@ -206,16 +297,18 @@ export function disposePowerbarCoalescer(): void {
 	powerbarCoalescer.dispose();
 }
 
-export function clearPiCrewPowerbar(events: EventBus, ctx?: StatusContext): void {
+export function clearPiCrewPowerbar(events: EventBus): void {
 	lastActiveKey = undefined;
 	lastProgressKey = undefined;
+	lastStepsKey = undefined;
 	safeEmit(events, "powerbar:update", { id: "pi-crew-active" });
 	safeEmit(events, "powerbar:update", { id: "pi-crew-progress" });
-	setStatusFallback(ctx, undefined);
+	safeEmit(events, "powerbar:update", { id: "pi-crew-steps" });
 }
 
 /** Reset dedup state on session lifecycle events. */
 export function resetPowerbarDedupState(): void {
 	lastActiveKey = undefined;
 	lastProgressKey = undefined;
+	lastStepsKey = undefined;
 }