pi-crew 0.1.39 → 0.1.41

package/src/state/mailbox.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { TeamRunManifest } from "./types.ts";
 import { resolveRealContainedPath } from "../utils/safe-paths.ts";
+import { redactSecrets } from "../utils/redaction.ts";
 
 export type MailboxDirection = "inbox" | "outbox";
 export type MailboxMessageStatus = "queued" | "delivered" | "acknowledged";
@@ -17,6 +18,7 @@ export interface MailboxMessage {
 	status: MailboxMessageStatus;
 	taskId?: string;
 	acknowledgedAt?: string;
+	data?: Record<string, unknown>;
 }
 
 export interface MailboxDeliveryState {
@@ -133,7 +135,7 @@ function parseMailboxMessage(raw: unknown, expectedDirection: MailboxDirection):
 	const obj = raw as Record<string, unknown>;
 	if (typeof obj.id !== "string" || typeof obj.runId !== "string" || !isDirection(obj.direction) || typeof obj.from !== "string" || typeof obj.to !== "string" || typeof obj.body !== "string" || typeof obj.createdAt !== "string" || !isStatus(obj.status)) return undefined;
 	if (obj.direction !== expectedDirection) return undefined;
-	return { id: obj.id, runId: obj.runId, direction: obj.direction, from: obj.from, to: obj.to, body: obj.body, createdAt: obj.createdAt, status: obj.status, taskId: typeof obj.taskId === "string" ? obj.taskId : undefined, acknowledgedAt: typeof obj.acknowledgedAt === "string" ? obj.acknowledgedAt : undefined };
+	return { id: obj.id, runId: obj.runId, direction: obj.direction, from: obj.from, to: obj.to, body: obj.body, createdAt: obj.createdAt, status: obj.status, taskId: typeof obj.taskId === "string" ? obj.taskId : undefined, acknowledgedAt: typeof obj.acknowledgedAt === "string" ? obj.acknowledgedAt : undefined, data: obj.data && typeof obj.data === "object" && !Array.isArray(obj.data) ? obj.data as Record<string, unknown> : undefined };
 }
 
 function readMailboxFile(filePath: string, direction: MailboxDirection): MailboxMessage[] {
@@ -190,7 +192,7 @@ export function readDeliveryState(manifest: TeamRunManifest): MailboxDeliverySta
 
 function writeDeliveryState(manifest: TeamRunManifest, state: MailboxDeliveryState): void {
 	ensureRunMailbox(manifest);
-	fs.writeFileSync(deliveryFile(manifest, true), `${JSON.stringify(state, null, 2)}\n`, "utf-8");
+	fs.writeFileSync(deliveryFile(manifest, true), `${JSON.stringify(redactSecrets(state), null, 2)}\n`, "utf-8");
 }
 
 export function appendMailboxMessage(manifest: TeamRunManifest, message: Omit<MailboxMessage, "id" | "runId" | "createdAt" | "status"> & { id?: string; status?: MailboxMessageStatus }): MailboxMessage {
@@ -207,8 +209,9 @@ export function appendMailboxMessage(manifest: TeamRunManifest, message: Omit<Ma
 		createdAt,
 		status: message.status ?? "queued",
 		taskId: message.taskId,
+		data: message.data,
 	};
-	fs.appendFileSync(mailboxFile(manifest, complete.direction, complete.taskId), `${JSON.stringify(complete)}\n`, "utf-8");
+	fs.appendFileSync(mailboxFile(manifest, complete.direction, complete.taskId), `${JSON.stringify(redactSecrets(complete))}\n`, "utf-8");
 	const delivery = readDeliveryState(manifest);
 	delivery.messages[complete.id] = complete.status;
 	delivery.updatedAt = createdAt;
@@ -216,6 +219,14 @@ export function appendMailboxMessage(manifest: TeamRunManifest, message: Omit<Ma
 	return complete;
 }
 
+export function findMailboxMessageByRequestId(manifest: TeamRunManifest, requestId: string): MailboxMessage | undefined {
+	return readMailbox(manifest).find((message) => message.data?.requestId === requestId);
+}
+
+export function readMailboxMessage(manifest: TeamRunManifest, messageId: string): MailboxMessage | undefined {
+	return readMailbox(manifest).find((message) => message.id === messageId);
+}
+
 export function acknowledgeMailboxMessage(manifest: TeamRunManifest, messageId: string): MailboxDeliveryState {
 	const delivery = readDeliveryState(manifest);
 	if (!delivery.messages[messageId]) throw new Error(`Mailbox message '${messageId}' not found.`);
@@ -249,7 +260,7 @@ export function validateMailbox(manifest: TeamRunManifest, options: { repair?: b
 				const parsed = JSON.parse(line) as unknown;
 				const message = parseMailboxMessage(parsed, direction);
 				if (!message) throw new Error("invalid message schema");
-				validLines.push(JSON.stringify(message));
+				validLines.push(JSON.stringify(redactSecrets(message)));
 			} catch (error) {
 				const message = error instanceof Error ? error.message : String(error);
 				issues.push({ level: "error", path: filePath, message });

package/src/state/types.ts

@@ -81,6 +81,30 @@ export interface AsyncRunState {
 	spawnedAt: string;
 }
 
+export interface PlanApprovalState {
+	required: boolean;
+	status: "pending" | "approved" | "cancelled";
+	requestedAt: string;
+	updatedAt: string;
+	approvedAt?: string;
+	cancelledAt?: string;
+	planTaskId?: string;
+	planArtifactPath?: string;
+}
+
+export type CrewActivityState = "active" | "active_long_running" | "needs_attention" | "stale";
+export type CrewAttentionReason = "idle" | "tool_failures" | "completion_guard" | "heartbeat_stale" | "plan_approval_pending";
+
+export interface CrewAttentionEventData {
+	activityState: CrewActivityState;
+	reason: CrewAttentionReason;
+	elapsedMs?: number;
+	taskId?: string;
+	agentName?: string;
+	suggestedAction?: string;
+	observedTools?: string[];
+}
+
 export interface TeamRunManifest {
 	schemaVersion: 1;
 	runId: string;
@@ -98,6 +122,7 @@ export interface TeamRunManifest {
 	eventsPath: string;
 	artifacts: ArtifactDescriptor[];
 	async?: AsyncRunState;
+	planApproval?: PlanApprovalState;
 	summary?: string;
 	policyDecisions?: PolicyDecision[];
 }

package/src/teams/discover-teams.ts

@@ -109,7 +109,7 @@ export function discoverTeams(cwd: string): TeamDiscoveryResult {
 
 export function allTeams(discovery: TeamDiscoveryResult): TeamConfig[] {
 	const byName = new Map<string, TeamConfig>();
-	for (const team of [...discovery.builtin, ...discovery.user, ...discovery.project]) {
+	for (const team of [...discovery.project, ...discovery.builtin, ...discovery.user]) {
 		byName.set(team.name, team);
 	}
 	return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));

package/src/ui/dashboard-panes/progress-pane.ts

@@ -3,8 +3,11 @@ import type { RunUiSnapshot } from "../snapshot-types.ts";
 export function renderProgressPane(snapshot: RunUiSnapshot | undefined): string[] {
 	if (!snapshot) return ["Progress pane: snapshot unavailable"];
 	const progress = snapshot.progress;
+	const groupJoins = snapshot.groupJoins ?? [];
+	const groupJoinLines = groupJoins.length ? groupJoins.map((item) => `group join ${item.partial ? "partial" : "completed"}: ${item.requestId} ack=${item.ack}`) : ["group joins: none"];
 	return [
 		`Progress pane: ${progress.completed}/${progress.total} completed · running=${progress.running} queued=${progress.queued} failed=${progress.failed}`,
+		...groupJoinLines,
 		...snapshot.recentEvents.slice(-10).map((event) => {
 			const seq = event.metadata?.seq !== undefined ? `#${event.metadata.seq}` : "#?";
 			return `${seq} ${event.time} ${event.type}${event.taskId ? ` ${event.taskId}` : ""}${event.message ? ` · ${event.message}` : ""}`;

package/src/ui/run-snapshot-cache.ts

@@ -8,7 +8,7 @@ import { readEvents, type TeamEvent } from "../state/event-log.ts";
 import type { MailboxMessageStatus } from "../state/mailbox.ts";
 import { loadRunManifestById } from "../state/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import type { RunSnapshotCache, RunUiMailbox, RunUiProgress, RunUiSnapshot, RunUiUsage } from "./snapshot-types.ts";
+import type { RunSnapshotCache, RunUiGroupJoin, RunUiMailbox, RunUiProgress, RunUiSnapshot, RunUiUsage } from "./snapshot-types.ts";
 
 const DEFAULT_TTL_MS = 250;
 const DEFAULT_MAX_ENTRIES = 24;
@@ -195,6 +195,25 @@ function readDeliveryMessages(filePath: string): Record<string, MailboxMessageSt
 	}
 }
 
+function readGroupJoinMailbox(filePath: string, delivery: Record<string, MailboxMessageStatus>): RunUiGroupJoin[] {
+	try {
+		return fs.readFileSync(filePath, "utf-8").split(/\r?\n/).filter(Boolean).flatMap((line) => {
+			try {
+				const parsed = JSON.parse(line) as unknown;
+				if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
+				const message = parsed as { id?: unknown; data?: unknown };
+				const data = message.data && typeof message.data === "object" && !Array.isArray(message.data) ? message.data as Record<string, unknown> : undefined;
+				if (typeof message.id !== "string" || data?.kind !== "group_join" || typeof data.requestId !== "string") return [];
+				return [{ requestId: data.requestId, messageId: message.id, partial: data.partial === true, ack: delivery[message.id] === "acknowledged" ? "acknowledged" as const : "pending" as const }];
+			} catch {
+				return [];
+			}
+		});
+	} catch {
+		return [];
+	}
+}
+
 function readMailboxCounts(filePath: string, delivery: Record<string, MailboxMessageStatus>): number {
 	try {
 		return fs.readFileSync(filePath, "utf-8").split(/\r?\n/).filter(Boolean).reduce((count, line) => {
@@ -213,6 +232,12 @@ function readMailboxCounts(filePath: string, delivery: Record<string, MailboxMes
 	}
 }
 
+function groupJoinsFrom(manifest: TeamRunManifest): RunUiGroupJoin[] {
+	const root = path.join(manifest.stateRoot, "mailbox");
+	const delivery = readDeliveryMessages(path.join(root, "delivery.json"));
+	return readGroupJoinMailbox(path.join(root, "outbox.jsonl"), delivery).slice(-5);
+}
+
 function mailboxFrom(manifest: TeamRunManifest, agents: CrewAgentRecord[]): RunUiMailbox {
 	const root = path.join(manifest.stateRoot, "mailbox");
 	const delivery = readDeliveryMessages(path.join(root, "delivery.json"));
@@ -241,6 +266,7 @@ function signatureFor(input: Omit<RunUiSnapshot, "signature" | "fetchedAt">, sta
 		progress: input.progress,
 		usage: input.usage,
 		mailbox: input.mailbox,
+		groupJoins: input.groupJoins,
 		events: input.recentEvents.map((event) => [event.metadata?.seq, event.time, event.type, event.taskId, event.message]),
 		output: input.recentOutputLines,
 		stamps,
@@ -306,6 +332,7 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 			throw new Error(`Run '${runId}' could not be parsed.`);
 		}
 		const mailbox = mailboxFrom(loaded.manifest, agents);
+		const groupJoins = groupJoinsFrom(loaded.manifest);
 		const base = {
 			runId: loaded.manifest.runId,
 			cwd: loaded.manifest.cwd,
@@ -315,6 +342,7 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 			progress: progressFromTasks(tasks),
 			usage: usageFrom(tasks, agents),
 			mailbox,
+			groupJoins,
 			recentEvents: safeRecentEvents(loaded.manifest.eventsPath, recentEventsLimit),
 			recentOutputLines: recentOutputLines(loaded.manifest, agents, recentOutputLimit),
 		};

package/src/ui/snapshot-types.ts

@@ -22,6 +22,13 @@ export interface RunUiMailbox {
 	needsAttention: number;
 }
 
+export interface RunUiGroupJoin {
+	requestId: string;
+	messageId: string;
+	partial: boolean;
+	ack: "pending" | "acknowledged";
+}
+
 export interface RunUiSnapshot {
 	runId: string;
 	cwd: string;
@@ -33,6 +40,7 @@ export interface RunUiSnapshot {
 	progress: RunUiProgress;
 	usage: RunUiUsage;
 	mailbox: RunUiMailbox;
+	groupJoins?: RunUiGroupJoin[];
 	recentEvents: TeamEvent[];
 	recentOutputLines: string[];
 }

package/src/utils/fs-watch.ts

@@ -18,14 +18,14 @@ export function closeWatcher(watcher: FSWatcher | null | undefined): void {
 export function watchWithErrorHandler(
 	path: string,
 	listener: WatchListener<string>,
-	onError: () => void,
+	onError: (error?: unknown) => void,
 ): FSWatcher | null {
 	try {
 		const watcher = fs.watch(path, listener);
 		watcher.on("error", onError);
 		return watcher;
-	} catch {
-		onError();
+	} catch (error) {
+		onError(error);
 		return null;
 	}
 }

package/src/utils/redaction.ts

@@ -0,0 +1,41 @@
+const SECRET_KEY_PATTERN = /(?:^|[_.-])(token|api[-_]?key|password|passwd|secret|credential|authorization|private[-_]?key)(?:$|[_.-])/i;
+const INLINE_SECRET_PATTERN = /(^|[\s,{])(([A-Za-z0-9_.-]*(?:api[-_]?key|token|password|passwd|secret|credential|authorization|private[-_]?key)[A-Za-z0-9_.-]*)\s*[=:]\s*)([^\s,;"'}]+)/gi;
+const AUTH_HEADER_PATTERN = /\b(Authorization\s*:\s*(?:Bearer|Basic|Token)?\s*)([^\r\n]+)/gi;
+const BEARER_PATTERN = /\b(Bearer\s+)([A-Za-z0-9._~+/=-]{8,})\b/g;
+const PEM_PRIVATE_KEY_PATTERN = /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function isSecretKey(keyName: string): boolean {
+	return SECRET_KEY_PATTERN.test(keyName) || /^(token|apiKey|api_key|password|secret|credential|authorization|privateKey|private_key)$/i.test(keyName);
+}
+
+export function redactSecretString(value: string): string {
+	return value
+		.replace(PEM_PRIVATE_KEY_PATTERN, "***")
+		.replace(AUTH_HEADER_PATTERN, "$1***")
+		.replace(BEARER_PATTERN, "$1***")
+		.replace(INLINE_SECRET_PATTERN, "$1$2***");
+}
+
+export function redactSecrets(value: unknown, keyName = ""): unknown {
+	if (keyName && isSecretKey(keyName)) return "***";
+	if (typeof value === "string") return redactSecretString(value);
+	if (Array.isArray(value)) return value.map((item) => redactSecrets(item));
+	if (isRecord(value)) {
+		const output: Record<string, unknown> = {};
+		for (const [key, entry] of Object.entries(value)) output[key] = redactSecrets(entry, key);
+		return output;
+	}
+	return value;
+}
+
+export function redactJsonLine(line: string): string {
+	try {
+		return JSON.stringify(redactSecrets(JSON.parse(line) as unknown));
+	} catch {
+		return redactSecretString(line);
+	}
+}

package/src/workflows/discover-workflows.ts

@@ -129,7 +129,7 @@ export function discoverWorkflows(cwd: string): WorkflowDiscoveryResult {
 
 export function allWorkflows(discovery: WorkflowDiscoveryResult): WorkflowConfig[] {
 	const byName = new Map<string, WorkflowConfig>();
-	for (const workflow of [...discovery.builtin, ...discovery.user, ...discovery.project]) {
+	for (const workflow of [...discovery.project, ...discovery.builtin, ...discovery.user]) {
 		byName.set(workflow.name, workflow);
 	}
 	return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));