pi-crew 0.9.16 → 0.9.17

package/src/extension/cross-extension-rpc.ts

@@ -3,8 +3,12 @@ import type { TeamToolParamsValue } from "../schema/team-tool-schema.ts";
 import { resolveContainedPath } from "../utils/safe-paths.ts";
 // Lazy-loaded to avoid pulling team-tool.ts (and its entire runtime chain) into module load.
 import type { handleTeamTool as HandleTeamToolFn } from "./team-tool.ts";
+
 let _cachedHandleTeamTool: typeof HandleTeamToolFn | undefined;
-async function handleTeamTool(params: Parameters<typeof HandleTeamToolFn>[0], ctx: Parameters<typeof HandleTeamToolFn>[1]): Promise<Awaited<ReturnType<typeof HandleTeamToolFn>>> {
+async function handleTeamTool(
+	params: Parameters<typeof HandleTeamToolFn>[0],
+	ctx: Parameters<typeof HandleTeamToolFn>[1],
+): Promise<Awaited<ReturnType<typeof HandleTeamToolFn>>> {
 	if (!_cachedHandleTeamTool) {
 		// LAZY: avoid pulling team-tool.ts (and its entire runtime chain) into module load.
 		const mod = await import("./team-tool.ts");
@@ -12,6 +16,7 @@ async function handleTeamTool(params: Parameters<typeof HandleTeamToolFn>[0], ct
 	}
 	return _cachedHandleTeamTool(params, ctx);
 }
+
 import { parseLiveControlRealtimeMessage, publishLiveControlRealtime } from "../runtime/live-control-realtime.ts";
 
 export interface EventBusLike {
@@ -27,7 +32,9 @@ export interface PiCrewRpcHandle {
 }
 
 function requestId(raw: unknown): string | undefined {
-	return raw && typeof raw === "object" && !Array.isArray(raw) && typeof (raw as { requestId?: unknown }).requestId === "string" ? (raw as { requestId: string }).requestId : undefined;
+	return raw && typeof raw === "object" && !Array.isArray(raw) && typeof (raw as { requestId?: unknown }).requestId === "string"
+		? (raw as { requestId: string }).requestId
+		: undefined;
 }
 
 function reply(events: EventBusLike, channel: string, id: string | undefined, payload: RpcReply): void {
@@ -38,7 +45,7 @@ function reply(events: EventBusLike, channel: string, id: string | undefined, pa
 }
 
 function textOf(result: Awaited<ReturnType<typeof handleTeamTool>>): string {
-	return result.content?.map((item) => item.type === "text" ? item.text : "").join("\n") ?? "";
+	return result.content?.map((item) => (item.type === "text" ? item.text : "")).join("\n") ?? "";
 }
 
 // SECURITY: Strictly enumerate allowed operations per RPC channel.
@@ -46,13 +53,23 @@ function textOf(result: Awaited<ReturnType<typeof handleTeamTool>>): string {
 // from mutating run state without user consent.
 const RPC_ALLOWED_OPERATIONS = new Set([
 	// Read-only manifest/plan ops
-	"metrics-snapshot", "inventory", "read-manifest",
-	"list-tasks", "read-task", "read-events",
+	"metrics-snapshot",
+	"inventory",
+	"read-manifest",
+	"list-tasks",
+	"read-task",
+	"read-events",
 	// Read-only agent ops
-	"list-agents", "read-agent-status", "read-agent-events",
-	"read-agent-transcript", "read-agent-output", "agent-dashboard",
+	"list-agents",
+	"read-agent-status",
+	"read-agent-events",
+	"read-agent-transcript",
+	"read-agent-output",
+	"agent-dashboard",
 	// Mailbox read ops
-	"read-mailbox", "read-delivery", "read-heartbeat",
+	"read-mailbox",
+	"read-delivery",
+	"read-heartbeat",
 	// No mutating ops (approve-plan, cancel-plan, steer-agent, stop-agent, etc.)
 	// — these require explicit intent confirmation and are NOT allowed via RPC.
 ]);
@@ -91,20 +108,29 @@ export function resetRpcRateLimit(): void {
 	rpcRunTimestamps.length = 0;
 }
 
-function isAllowedRpcRunParams(params: TeamToolParamsValue): { ok: boolean; error?: string } {
+function isAllowedRpcRunParams(params: TeamToolParamsValue): {
+	ok: boolean;
+	error?: string;
+} {
 	// SECURITY: Require explicit intent for any RPC-initiated run creation.
 	// This prevents malicious extensions from spawning child Pi processes silently.
 	const cfg = params.config as Record<string, unknown> | undefined;
 	const intent = cfg?.intent as string | undefined;
 	if (!intent || typeof intent !== "string" || intent.trim().length === 0) {
-		return { ok: false, error: "RPC run requires config.intent (a non-empty intent string)" };
+		return {
+			ok: false,
+			error: "RPC run requires config.intent (a non-empty intent string)",
+		};
 	}
 	// SECURITY: Validate cwd is within the project directory if provided.
 	if (params.cwd && typeof params.cwd === "string") {
 		try {
 			resolveContainedPath(params.cwd, ".");
 		} catch {
-			return { ok: false, error: "RPC run config.cwd must be within the project directory" };
+			return {
+				ok: false,
+				error: "RPC run config.cwd must be within the project directory",
+			};
 		}
 	}
 	return { ok: true };
@@ -121,10 +147,18 @@ function on(events: EventBusLike, channel: string, handler: (raw: unknown) => vo
 // requirement for runs, operation allowlist for live-control reads, and cwd
 // containment validation. A full fix requires event-bus-level origin signing.
 
-export function registerPiCrewRpc(events: EventBusLike | undefined, getCtx: () => ExtensionContext | undefined): PiCrewRpcHandle | undefined {
+export function registerPiCrewRpc(
+	events: EventBusLike | undefined,
+	getCtx: () => ExtensionContext | undefined,
+): PiCrewRpcHandle | undefined {
 	if (!events) return undefined;
 	const unsubs = [
-		on(events, "pi-crew:rpc:ping", (raw) => reply(events, "pi-crew:rpc:ping", requestId(raw), { success: true, data: { version: PI_CREW_RPC_VERSION } })),
+		on(events, "pi-crew:rpc:ping", (raw) =>
+			reply(events, "pi-crew:rpc:ping", requestId(raw), {
+				success: true,
+				data: { version: PI_CREW_RPC_VERSION },
+			}),
+		),
 		on(events, "pi-crew:rpc:run", async (raw) => {
 			const id = requestId(raw);
 			try {
@@ -144,24 +178,40 @@ export function registerPiCrewRpc(events: EventBusLike | undefined, getCtx: () =
 				const ALLOWED_RPC_RUN_KEYS = new Set(["goal", "team", "workflow", "async", "cwd", "config", "skill", "model"]);
 				let params: TeamToolParamsValue;
 				if (raw && typeof raw === "object" && !Array.isArray(raw)) {
-					const filtered: Record<string, unknown> = { ...(raw as object) };
+					const filtered: Record<string, unknown> = {
+						...(raw as object),
+					};
 					// Strip any keys not in the allowlist to prevent injection of unexpected fields
 					for (const key of Object.keys(filtered)) {
 						if (!ALLOWED_RPC_RUN_KEYS.has(key)) delete filtered[key];
 					}
-					params = { ...filtered, action: "run" } as TeamToolParamsValue;
+					params = {
+						...filtered,
+						action: "run",
+					} as TeamToolParamsValue;
 				} else {
 					params = { action: "run" };
 				}
 				const permission = isAllowedRpcRunParams(params);
 				if (!permission.ok) {
-					reply(events, "pi-crew:rpc:run", id, { success: false, error: permission.error ?? "permission denied" });
+					reply(events, "pi-crew:rpc:run", id, {
+						success: false,
+						error: permission.error ?? "permission denied",
+					});
 					return;
 				}
 				const result = await handleTeamTool(params, ctx);
-				reply(events, "pi-crew:rpc:run", id, result.isError ? { success: false, error: textOf(result) } : { success: true, data: result.details });
+				reply(
+					events,
+					"pi-crew:rpc:run",
+					id,
+					result.isError ? { success: false, error: textOf(result) } : { success: true, data: result.details },
+				);
 			} catch (error) {
-				reply(events, "pi-crew:rpc:run", id, { success: false, error: error instanceof Error ? error.message : String(error) });
+				reply(events, "pi-crew:rpc:run", id, {
+					success: false,
+					error: error instanceof Error ? error.message : String(error),
+				});
 			}
 		}),
 		on(events, "pi-crew:rpc:status", async (raw) => {
@@ -171,38 +221,82 @@ export function registerPiCrewRpc(events: EventBusLike | undefined, getCtx: () =
 				if (!ctx) throw new Error("No active pi-crew session context.");
 				const runId = raw && typeof raw === "object" && !Array.isArray(raw) ? (raw as { runId?: string }).runId : undefined;
 				const result = await handleTeamTool({ action: "status", runId }, ctx);
-				reply(events, "pi-crew:rpc:status", id, result.isError ? { success: false, error: textOf(result) } : { success: true, data: { text: textOf(result), details: result.details } });
+				reply(
+					events,
+					"pi-crew:rpc:status",
+					id,
+					result.isError
+						? { success: false, error: textOf(result) }
+						: {
+								success: true,
+								data: {
+									text: textOf(result),
+									details: result.details,
+								},
+							},
+				);
 			} catch (error) {
-				reply(events, "pi-crew:rpc:status", id, { success: false, error: error instanceof Error ? error.message : String(error) });
+				reply(events, "pi-crew:rpc:status", id, {
+					success: false,
+					error: error instanceof Error ? error.message : String(error),
+				});
 			}
 		}),
 		on(events, "pi-crew:live-control", (raw) => {
 			const request = parseLiveControlRealtimeMessage(raw);
 			if (request) publishLiveControlRealtime(request);
 		}),
-			on(events, "pi-crew:rpc:live-control", async (raw) => {
-				const id = requestId(raw);
-				try {
-					const ctx = getCtx();
-					if (!ctx) throw new Error("No active pi-crew session context.");
-					const obj = raw && typeof raw === "object" && !Array.isArray(raw) ? raw as Record<string, unknown> : {};
-					const rawOp = typeof obj.operation === "string" ? obj.operation : "steer-agent";
-					// SECURITY: Reject any operation not in the explicit allowlist.
-					// Mutating ops (approve-plan, cancel-plan, steer-agent, stop-agent, etc.)
-					// require user consent and are blocked here.
-					if (!isAllowedRpcOperation(rawOp)) {
-						reply(events, "pi-crew:rpc:live-control", id, {
-							success: false,
-							error: `RPC operation '${rawOp}' is not allowed. Allowed: ${[...RPC_ALLOWED_OPERATIONS].join(", ")}`,
-						});
-						return;
-					}
-					const result = await handleTeamTool({ action: "api", runId: typeof obj.runId === "string" ? obj.runId : undefined, config: { operation: rawOp, agentId: obj.agentId, message: obj.message, prompt: obj.prompt } }, ctx);
-					reply(events, "pi-crew:rpc:live-control", id, result.isError ? { success: false, error: textOf(result) } : { success: true, data: { text: textOf(result), details: result.details } });
-				} catch (error) {
-					reply(events, "pi-crew:rpc:live-control", id, { success: false, error: error instanceof Error ? error.message : String(error) });
+		on(events, "pi-crew:rpc:live-control", async (raw) => {
+			const id = requestId(raw);
+			try {
+				const ctx = getCtx();
+				if (!ctx) throw new Error("No active pi-crew session context.");
+				const obj = raw && typeof raw === "object" && !Array.isArray(raw) ? (raw as Record<string, unknown>) : {};
+				const rawOp = typeof obj.operation === "string" ? obj.operation : "steer-agent";
+				// SECURITY: Reject any operation not in the explicit allowlist.
+				// Mutating ops (approve-plan, cancel-plan, steer-agent, stop-agent, etc.)
+				// require user consent and are blocked here.
+				if (!isAllowedRpcOperation(rawOp)) {
+					reply(events, "pi-crew:rpc:live-control", id, {
+						success: false,
+						error: `RPC operation '${rawOp}' is not allowed. Allowed: ${[...RPC_ALLOWED_OPERATIONS].join(", ")}`,
+					});
+					return;
 				}
-			}),
+				const result = await handleTeamTool(
+					{
+						action: "api",
+						runId: typeof obj.runId === "string" ? obj.runId : undefined,
+						config: {
+							operation: rawOp,
+							agentId: obj.agentId,
+							message: obj.message,
+							prompt: obj.prompt,
+						},
+					},
+					ctx,
+				);
+				reply(
+					events,
+					"pi-crew:rpc:live-control",
+					id,
+					result.isError
+						? { success: false, error: textOf(result) }
+						: {
+								success: true,
+								data: {
+									text: textOf(result),
+									details: result.details,
+								},
+							},
+				);
+			} catch (error) {
+				reply(events, "pi-crew:rpc:live-control", id, {
+					success: false,
+					error: error instanceof Error ? error.message : String(error),
+				});
+			}
+		}),
 	];
 	return { unsubscribe: () => unsubs.forEach((unsub) => unsub()) };
 }

package/src/extension/help.ts

@@ -11,7 +11,7 @@ export function piTeamsHelp(): string {
 		"- /team-summary <runId>",
 		"- /team-resume <runId>",
 		"- /team-cancel <runId>",
-	"- /team-retry <runId> [taskId]",
+		"- /team-retry <runId> [taskId]",
 		"",
 		"Inspection:",
 		"- /team-events <runId>",

package/src/extension/import-index.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
 import { DEFAULT_PATHS } from "../config/defaults.ts";
+import { projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
 import { isSafePathId, resolveRealContainedPath } from "../utils/safe-paths.ts";
 
 export interface ImportedRunIndexEntry {
@@ -30,7 +30,10 @@ function readEntry(root: string, scope: "project" | "user", runId: string): Impo
 	if (!fs.existsSync(bundlePath)) return undefined;
 	try {
 		const raw = JSON.parse(fs.readFileSync(bundlePath, "utf-8")) as Record<string, unknown>;
-		const manifest = raw.manifest && typeof raw.manifest === "object" && !Array.isArray(raw.manifest) ? raw.manifest as Record<string, unknown> : {};
+		const manifest =
+			raw.manifest && typeof raw.manifest === "object" && !Array.isArray(raw.manifest)
+				? (raw.manifest as Record<string, unknown>)
+				: {};
 		return {
 			runId,
 			scope,
@@ -55,7 +58,8 @@ function collect(root: string, scope: "project" | "user"): ImportedRunIndexEntry
 	} catch {
 		return [];
 	}
-	return fs.readdirSync(root)
+	return fs
+		.readdirSync(root)
 		.filter((entry) => isSafePathId(entry))
 		.map((entry) => readEntry(root, scope, entry))
 		.filter((entry): entry is ImportedRunIndexEntry => entry !== undefined);
@@ -64,6 +68,7 @@ function collect(root: string, scope: "project" | "user"): ImportedRunIndexEntry
 export function listImportedRuns(cwd: string): ImportedRunIndexEntry[] {
 	const projectRoot = path.join(projectCrewRoot(cwd), DEFAULT_PATHS.state.importsSubdir);
 	const userRoot = path.join(userCrewRoot(), DEFAULT_PATHS.state.importsSubdir);
-	return [...collect(userRoot, "user"), ...collect(projectRoot, "project")]
-		.sort((a, b) => (b.importedAt ?? "").localeCompare(a.importedAt ?? ""));
+	return [...collect(userRoot, "user"), ...collect(projectRoot, "project")].sort((a, b) =>
+		(b.importedAt ?? "").localeCompare(a.importedAt ?? ""),
+	);
 }

package/src/extension/knowledge-injection.ts

@@ -22,8 +22,8 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { BeforeAgentStartEvent, ExtensionAPI } from "./pi-api.ts";
 import { projectCrewRoot } from "../utils/paths.ts";
+import type { BeforeAgentStartEvent, ExtensionAPI } from "./pi-api.ts";
 
 /** The knowledge file, relative to the project crew root. */
 export const KNOWLEDGE_FILENAME = "knowledge.md";
@@ -73,10 +73,45 @@ interface KnowledgeSection {
 }
 
 const STOPWORDS = new Set([
-	"the", "a", "an", "is", "are", "of", "to", "in", "for", "and", "or", "not",
-	"with", "this", "that", "it", "be", "on", "at", "by", "do", "does", "how",
-	"what", "when", "from", "fix", "fixes", "fixed", "v0", "v1", "released",
-	"progress", "uncommitted", "not", "pushed", "published", "session", "post",
+	"the",
+	"a",
+	"an",
+	"is",
+	"are",
+	"of",
+	"to",
+	"in",
+	"for",
+	"and",
+	"or",
+	"not",
+	"with",
+	"this",
+	"that",
+	"it",
+	"be",
+	"on",
+	"at",
+	"by",
+	"do",
+	"does",
+	"how",
+	"what",
+	"when",
+	"from",
+	"fix",
+	"fixes",
+	"fixed",
+	"v0",
+	"v1",
+	"released",
+	"progress",
+	"uncommitted",
+	"not",
+	"pushed",
+	"published",
+	"session",
+	"post",
 ]);
 
 /** Tokenize header text into a Set of lowercased non-stopword tokens. */
@@ -91,20 +126,33 @@ function tokenizeHeader(header: string): Set<string> {
 }
 
 /** Parse knowledge.md into (conventions, sessionLog) sections by H2 header. */
-function parseKnowledgeSections(content: string): { conventions: KnowledgeSection[]; sessionLog: KnowledgeSection[] } {
+function parseKnowledgeSections(content: string): {
+	conventions: KnowledgeSection[];
+	sessionLog: KnowledgeSection[];
+} {
 	const lines = content.split(/\r?\n/);
 	const sections: KnowledgeSection[] = [];
 	let current: { header: string; lines: string[] } | null = null;
 	for (const line of lines) {
 		const m = /^##\s+(.+?)\s*$/.exec(line);
 		if (m) {
-			if (current) sections.push({ header: current.header, body: current.lines.join("\n"), headerTokens: tokenizeHeader(current.header) });
+			if (current)
+				sections.push({
+					header: current.header,
+					body: current.lines.join("\n"),
+					headerTokens: tokenizeHeader(current.header),
+				});
 			current = { header: m[1]!, lines: [line] };
 		} else if (current) {
 			current.lines.push(line);
 		}
 	}
-	if (current) sections.push({ header: current.header, body: current.lines.join("\n"), headerTokens: tokenizeHeader(current.header) });
+	if (current)
+		sections.push({
+			header: current.header,
+			body: current.lines.join("\n"),
+			headerTokens: tokenizeHeader(current.header),
+		});
 
 	// Classify: a section is a CONVENTION if its header starts-with one of the
 	// known convention titles. Once we leave the convention run (first non-
@@ -168,7 +216,12 @@ function selectSessionLog(query: string, sessionLog: KnowledgeSection[], budgetB
 	const scored = sessionLog
 		.map((sec, idx) => {
 			const overlap = [...queryTokens].filter((t) => sec.headerTokens.has(t));
-			return { sec, score: overlap.reduce((sum, t) => sum + (idf.get(t) ?? 0), 0), idx, hasOverlap: overlap.length > 0 };
+			return {
+				sec,
+				score: overlap.reduce((sum, t) => sum + (idf.get(t) ?? 0), 0),
+				idx,
+				hasOverlap: overlap.length > 0,
+			};
 		})
 		.filter((x) => x.hasOverlap);
 	if (scored.length === 0) return [];
@@ -188,7 +241,10 @@ function selectSessionLog(query: string, sessionLog: KnowledgeSection[], budgetB
 	// a head-sliced copy of the single best match so the query isn't empty.
 	if (selected.length === 0 && bestMatch) {
 		const sliced = bestMatch.sec.body.slice(0, Math.max(0, budgetBytes));
-		selected.push({ ...bestMatch.sec, body: `${sliced}\n\n<!-- section truncated (session-log budget ${budgetBytes} bytes). Full file: use \`read\`. -->` });
+		selected.push({
+			...bestMatch.sec,
+			body: `${sliced}\n\n<!-- section truncated (session-log budget ${budgetBytes} bytes). Full file: use \`read\`. -->`,
+		});
 	}
 	return selected;
 }
@@ -225,13 +281,23 @@ export function readKnowledge(cwd: string, query?: KnowledgeQuery): string {
 
 		// Section-aware path: cache parsed sections, select per-query.
 		const cachedSections = sectionCache.get(p);
-		let parsed: { conventions: KnowledgeSection[]; sessionLog: KnowledgeSection[] };
+		let parsed: {
+			conventions: KnowledgeSection[];
+			sessionLog: KnowledgeSection[];
+		};
 		if (cachedSections && cachedSections.key === cacheKey) {
-			parsed = { conventions: cachedSections.conventions, sessionLog: cachedSections.sessionLog };
+			parsed = {
+				conventions: cachedSections.conventions,
+				sessionLog: cachedSections.sessionLog,
+			};
 		} else {
 			const content = fs.readFileSync(p, "utf8").trim();
 			parsed = parseKnowledgeSections(content);
-			sectionCache.set(p, { key: cacheKey, conventions: parsed.conventions, sessionLog: parsed.sessionLog });
+			sectionCache.set(p, {
+				key: cacheKey,
+				conventions: parsed.conventions,
+				sessionLog: parsed.sessionLog,
+			});
 		}
 
 		const queryText = [query.goal, query.taskText].filter(Boolean).join(" \n ");
@@ -245,7 +311,9 @@ export function readKnowledge(cwd: string, query?: KnowledgeQuery): string {
 		// Always: section-index of ALL session-log headers (recovery safety net).
 		if (parsed.sessionLog.length > 0) {
 			const indexLines = parsed.sessionLog.map((s) => `  - ${s.header}`);
-			parts.push(`<!-- Session-log sections in knowledge.md (not injected unless matched above — use \`read\` for detail):\n${indexLines.join("\n")}\nFull file: ${p} -->`);
+			parts.push(
+				`<!-- Session-log sections in knowledge.md (not injected unless matched above — use \`read\` for detail):\n${indexLines.join("\n")}\nFull file: ${p} -->`,
+			);
 		}
 		return parts.join("\n").trim();
 	} catch {
@@ -311,7 +379,12 @@ export function buildKnowledgeFragment(cwd: string, query?: KnowledgeQuery): str
  */
 export function registerKnowledgeInjection(pi: ExtensionAPI): void {
 	pi.on("before_agent_start", (event: BeforeAgentStartEvent) => {
-		const options = (event as BeforeAgentStartEvent & { systemPromptOptions?: { cwd?: unknown } }).systemPromptOptions ?? {};
+		const options =
+			(
+				event as BeforeAgentStartEvent & {
+					systemPromptOptions?: { cwd?: unknown };
+				}
+			).systemPromptOptions ?? {};
 		const cwd = typeof options.cwd === "string" ? options.cwd : process.cwd();
 		const fragment = buildKnowledgeFragment(cwd);
 		if (!fragment) return undefined;