pi-crew 0.9.16 → 0.9.17

package/src/runtime/runtime-resolver.ts

@@ -31,22 +31,38 @@ export function runtimeResolutionState(runtime: CrewRuntimeCapabilities, resolve
 	};
 }
 
-export async function isLiveSessionRuntimeAvailable(timeoutMs = 1500, env: NodeJS.ProcessEnv = process.env): Promise<{ available: boolean; reason?: string }> {
+export async function isLiveSessionRuntimeAvailable(
+	timeoutMs = 1500,
+	env: NodeJS.ProcessEnv = process.env,
+): Promise<{ available: boolean; reason?: string }> {
 	if (env.PI_CREW_MOCK_LIVE_SESSION === "success") {
-		return { available: true, reason: "Mock live-session runtime is enabled." };
+		return {
+			available: true,
+			reason: "Mock live-session runtime is enabled.",
+		};
 	}
-	const probe = async (): Promise<{ available: boolean; reason?: string }> => {
+	const probe = async (): Promise<{
+		available: boolean;
+		reason?: string;
+	}> => {
 		try {
 			// LAZY: optional peer dependency — probe at runtime to avoid hard dependency.
 			const mod = await import("@earendil-works/pi-coding-agent");
 			const api = mod as Record<string, unknown>;
 			const required = ["createAgentSession", "DefaultResourceLoader", "SessionManager", "SettingsManager"];
 			const missing = required.filter((name) => typeof api[name] === "undefined");
-			if (missing.length) return { available: false, reason: `Pi SDK live-session exports missing: ${missing.join(", ")}.` };
+			if (missing.length)
+				return {
+					available: false,
+					reason: `Pi SDK live-session exports missing: ${missing.join(", ")}.`,
+				};
 			return { available: true };
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
-			return { available: false, reason: `Could not load optional Pi SDK live-session runtime: ${message}` };
+			return {
+				available: false,
+				reason: `Could not load optional Pi SDK live-session runtime: ${message}`,
+			};
 		}
 	};
 	let timer: NodeJS.Timeout | undefined;
@@ -54,7 +70,14 @@ export async function isLiveSessionRuntimeAvailable(timeoutMs = 1500, env: NodeJ
 		return await Promise.race([
 			probe(),
 			new Promise<{ available: boolean; reason: string }>((resolve) => {
-				timer = setTimeout(() => resolve({ available: false, reason: `Timed out probing optional Pi SDK live-session runtime after ${timeoutMs}ms.` }), timeoutMs);
+				timer = setTimeout(
+					() =>
+						resolve({
+							available: false,
+							reason: `Timed out probing optional Pi SDK live-session runtime after ${timeoutMs}ms.`,
+						}),
+					timeoutMs,
+				);
 				timer.unref();
 			}),
 		]);
@@ -67,16 +90,25 @@ export async function resolveCrewRuntime(config: PiTeamsConfig, env: NodeJS.Proc
 	const requestedMode = config.runtime?.mode ?? "auto";
 	const workersDisabled = config.executeWorkers === false || env.PI_CREW_EXECUTE_WORKERS === "0" || env.PI_TEAMS_EXECUTE_WORKERS === "0";
 	if (requestedMode === "scaffold") return scaffoldCaps(requestedMode, undefined, "explicit_dry_run");
-	if (workersDisabled) return scaffoldCaps(requestedMode, "Child worker execution disabled by config/env. Set runtime.mode=scaffold or executeWorkers=false only for dry runs.", "blocked");
+	if (workersDisabled)
+		return scaffoldCaps(
+			requestedMode,
+			"Child worker execution disabled by config/env. Set runtime.mode=scaffold or executeWorkers=false only for dry runs.",
+			"blocked",
+		);
 	if (requestedMode === "child-process") return childCaps(requestedMode);
 	// When a child-process mock is active (tests), force auto-mode to child-process where the mock is active.
-	if (requestedMode === "auto" && env.PI_TEAMS_MOCK_CHILD_PI) return childCaps(requestedMode, "PI_TEAMS_MOCK_CHILD_PI mock forces child-process runtime in auto mode.");
+	if (requestedMode === "auto" && env.PI_TEAMS_MOCK_CHILD_PI)
+		return childCaps(requestedMode, "PI_TEAMS_MOCK_CHILD_PI mock forces child-process runtime in auto mode.");
 	if (requestedMode === "live-session") {
 		const live = await isLiveSessionRuntimeAvailable(1500, env);
 		if (live.available) return liveCaps(requestedMode);
-		if (config.runtime?.allowChildProcessFallback === false)
-			return scaffoldCaps(requestedMode, live.reason, "blocked");
-		return { ...childCaps(requestedMode), fallback: "child-process", reason: live.reason };
+		if (config.runtime?.allowChildProcessFallback === false) return scaffoldCaps(requestedMode, live.reason, "blocked");
+		return {
+			...childCaps(requestedMode),
+			fallback: "child-process",
+			reason: live.reason,
+		};
 	}
 	// auto mode: use child-process unless preferLiveSession is explicitly enabled
 	if (requestedMode === "auto") {
@@ -94,14 +126,47 @@ export async function resolveCrewRuntime(config: PiTeamsConfig, env: NodeJS.Proc
 	return childCaps(requestedMode);
 }
 
-function scaffoldCaps(requestedMode: CrewRuntimeMode, reason?: string, safety: CrewRuntimeSafety = "explicit_dry_run"): CrewRuntimeCapabilities {
-	return { kind: "scaffold", requestedMode, available: safety !== "blocked", steer: false, resume: false, liveToolActivity: false, transcript: false, safety, ...(reason ? { reason } : {}) };
+function scaffoldCaps(
+	requestedMode: CrewRuntimeMode,
+	reason?: string,
+	safety: CrewRuntimeSafety = "explicit_dry_run",
+): CrewRuntimeCapabilities {
+	return {
+		kind: "scaffold",
+		requestedMode,
+		available: safety !== "blocked",
+		steer: false,
+		resume: false,
+		liveToolActivity: false,
+		transcript: false,
+		safety,
+		...(reason ? { reason } : {}),
+	};
 }
 
 function childCaps(requestedMode: CrewRuntimeMode, reason?: string): CrewRuntimeCapabilities {
-	return { kind: "child-process", requestedMode, available: true, steer: true, resume: false, liveToolActivity: false, transcript: true, safety: "trusted", ...(reason ? { reason } : {}) };
+	return {
+		kind: "child-process",
+		requestedMode,
+		available: true,
+		steer: true,
+		resume: false,
+		liveToolActivity: false,
+		transcript: true,
+		safety: "trusted",
+		...(reason ? { reason } : {}),
+	};
 }
 
 function liveCaps(requestedMode: CrewRuntimeMode): CrewRuntimeCapabilities {
-	return { kind: "live-session", requestedMode, available: true, steer: true, resume: true, liveToolActivity: true, transcript: true, safety: "trusted" };
+	return {
+		kind: "live-session",
+		requestedMode,
+		available: true,
+		steer: true,
+		resume: true,
+		liveToolActivity: true,
+		transcript: true,
+		safety: "trusted",
+	};
 }

package/src/runtime/scheduler.ts

@@ -34,15 +34,13 @@ export class CrewScheduler {
 	private finalizer?: (jobId: string, agentId: string) => void;
 	private runCancelFn?: (runId: string) => void;
 
-	start(
-		options: {
-			emit: (event: ScheduleChangeEvent) => void;
-			executor: (job: ScheduledJob) => string;
-			finalizer: (jobId: string, agentId: string) => void;
-			/** Optional callback to cancel a spawned run by runId. */
-			runCancelFn?: (runId: string) => void;
-		},
-	): void {
+	start(options: {
+		emit: (event: ScheduleChangeEvent) => void;
+		executor: (job: ScheduledJob) => string;
+		finalizer: (jobId: string, agentId: string) => void;
+		/** Optional callback to cancel a spawned run by runId. */
+		runCancelFn?: (runId: string) => void;
+	}): void {
 		this.emit = options.emit;
 		this.executor = options.executor;
 		this.finalizer = options.finalizer;
@@ -74,7 +72,11 @@ export class CrewScheduler {
 		// Cancel all spawned runs that are still active
 		if (spawnedRunIds && this.runCancelFn) {
 			for (const runId of spawnedRunIds) {
-				try { this.runCancelFn(runId); } catch { /* best-effort */ }
+				try {
+					this.runCancelFn(runId);
+				} catch {
+					/* best-effort */
+				}
 			}
 		}
 		const ok = this.jobs.delete(id);
@@ -121,7 +123,11 @@ export class CrewScheduler {
 				this.timers.set(job.id, t);
 			} else {
 				this.update(job.id, { enabled: false, lastStatus: "error" });
-				this.emit?.({ type: "error", jobId: job.id, error: `Scheduled time ${job.schedule} is in the past` });
+				this.emit?.({
+					type: "error",
+					jobId: job.id,
+					error: `Scheduled time ${job.schedule} is in the past`,
+				});
 			}
 		}
 	}
@@ -149,7 +155,10 @@ export class CrewScheduler {
 			agentId = this.executor(job);
 		} catch (err) {
 			const error = err instanceof Error ? err.message : String(err);
-			this.update(id, { lastRun: new Date().toISOString(), lastStatus: "error" });
+			this.update(id, {
+				lastRun: new Date().toISOString(),
+				lastStatus: "error",
+			});
 			this.emit?.({ type: "error", jobId: id, error });
 			return;
 		}
@@ -157,13 +166,20 @@ export class CrewScheduler {
 		this.finalizer?.(id, agentId);
 	}
 
-	static detectSchedule(s: string): { type: ScheduleType; intervalMs?: number; normalized: string } {
+	static detectSchedule(s: string): {
+		type: ScheduleType;
+		intervalMs?: number;
+		normalized: string;
+	} {
 		const trimmed = s.trim();
 		// Relative: +10m
 		const rel = trimmed.match(/^\+(\d+)(s|m|h|d)$/);
 		if (rel) {
 			const ms = parseInt(rel[1], 10) * { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }[rel[2] as "s" | "m" | "h" | "d"];
-			return { type: "once", normalized: new Date(Date.now() + ms).toISOString() };
+			return {
+				type: "once",
+				normalized: new Date(Date.now() + ms).toISOString(),
+			};
 		}
 		// Interval: 5m
 		const ivl = trimmed.match(/^(\d+)(s|m|h|d)$/);
@@ -196,7 +212,12 @@ export interface ScheduleSpec {
 function parseIntervalMs(s: string): number | undefined {
 	let ms = 0;
 	let remaining = s;
-	const unitMs: Record<string, number> = { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 };
+	const unitMs: Record<string, number> = {
+		s: 1000,
+		m: 60_000,
+		h: 3_600_000,
+		d: 86_400_000,
+	};
 	while (remaining.length > 0) {
 		const m = remaining.match(/^(\d+)(s|m|h|d)/);
 		if (!m) return undefined;
@@ -272,7 +293,9 @@ export function parseSchedule(spec: string): ScheduleSpec | { error: string } {
 	if (fields.length >= 5) {
 		return { kind: "cron", spec: trimmed };
 	}
-	return { error: `Invalid schedule "${spec}". Use "5m", "+10m", ISO timestamp, or cron expression.` };
+	return {
+		error: `Invalid schedule "${spec}". Use "5m", "+10m", ISO timestamp, or cron expression.`,
+	};
 }
 
 export function nextRunTime(spec: ScheduleSpec, from: Date = new Date()): Date | { error: string } {
@@ -298,11 +321,17 @@ export function nextRunTime(spec: ScheduleSpec, from: Date = new Date()): Date |
 	if (spec.kind === "cron") {
 		const next = nextCronDate(spec.spec, from);
 		if (!next || !(next instanceof Date)) {
-			return (next as { error: string } | null) ?? { error: "Invalid cron expression" };
+			return (
+				(next as { error: string } | null) ?? {
+					error: "Invalid cron expression",
+				}
+			);
 		}
 		return next;
 	}
-	return { error: `Unknown schedule kind: ${(spec as unknown as Record<string, unknown>).kind}` };
+	return {
+		error: `Unknown schedule kind: ${(spec as unknown as Record<string, unknown>).kind}`,
+	};
 }
 
 export function humanizeSchedule(spec: ScheduleSpec): string {

package/src/runtime/semaphore.ts

@@ -33,13 +33,13 @@ export class Semaphore {
 		// implementation let #queue grow without bound, risking memory
 		// exhaustion under sustained high concurrency with slow releases.
 		if (this.#queue.length >= Semaphore.MAX_QUEUE) {
-			throw new Error(
-				`Semaphore queue full: ${this.#queue.length} waiters (max ${Semaphore.MAX_QUEUE}); cannot acquire slot`,
-			);
+			throw new Error(`Semaphore queue full: ${this.#queue.length} waiters (max ${Semaphore.MAX_QUEUE}); cannot acquire slot`);
 		}
 		const { promise, resolve } = (() => {
 			let res: () => void;
-			const p = new Promise<void>((r) => { res = r; });
+			const p = new Promise<void>((r) => {
+				res = r;
+			});
 			return { promise: p, resolve: res! };
 		})();
 		this.#queue.push(resolve);
@@ -101,9 +101,7 @@ async function mapWithFailFast<T, R>(
 
 	// Internal abort controller for fail-fast
 	const abortController = new AbortController();
-	const workerSignal = signal
-		? AbortSignal.any([signal, abortController.signal])
-		: abortController.signal;
+	const workerSignal = signal ? AbortSignal.any([signal, abortController.signal]) : abortController.signal;
 
 	// Promise that rejects on first error — used for fail-fast
 	let rejectFirst: (error: unknown) => void;

package/src/runtime/sensitive-paths.ts

@@ -12,7 +12,8 @@ import * as path from "node:path";
 
 /** Basenames that almost certainly hold secrets or PII */
 const SENSITIVE_BASENAMES = /\.(?:env|pem|key|p12|pfx|crt|cer|jks|keystore|asc|gpg)(?:\..+)?$/i;
-const SENSITIVE_EXACT = /^(?:\.env|\.netrc|\.npmrc|\.pypirc|credentials|secrets?|passwords?|id_(?:rsa|dsa|ecdsa|ed25519)(?:\.pub)?|authorized_keys|known_hosts|jwt\.json|session\.cookie|\.token)$/i;
+const SENSITIVE_EXACT =
+	/^(?:\.env|\.netrc|\.npmrc|\.pypirc|credentials|secrets?|passwords?|id_(?:rsa|dsa|ecdsa|ed25519)(?:\.pub)?|authorized_keys|known_hosts|jwt\.json|session\.cookie|\.token)$/i;
 
 /** Path components that indicate sensitive directories */
 const SENSITIVE_DIRS = new Set([".ssh", ".aws", ".gnupg", ".kube", ".docker", ".config/gcloud", ".config/gh"]);

package/src/runtime/session-usage.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import type { UsageState } from "../state/types.ts";
 
 function asRecord(value: unknown): Record<string, unknown> | undefined {
-	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+	return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;
 }
 
 function numberField(obj: Record<string, unknown>, keys: string[]): number | undefined {

package/src/runtime/settings-store.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
-import * as path from "node:path";
 import { homedir } from "node:os";
+import * as path from "node:path";
 import { logInternalError } from "../utils/internal-error.ts";
 import type { JoinMode } from "./group-join.ts";
 
@@ -27,9 +27,7 @@ const VALID_JOIN_MODES = new Set<JoinMode>(["async", "group", "smart"]);
 function validateScheduledJob(job: unknown): boolean {
 	if (!job || typeof job !== "object") return false;
 	const obj = job as Record<string, unknown>;
-	return typeof obj.id === "string" && obj.id.length > 0
-		&& typeof obj.scheduleType === "string"
-		&& typeof obj.enabled === "boolean";
+	return typeof obj.id === "string" && obj.id.length > 0 && typeof obj.scheduleType === "string" && typeof obj.enabled === "boolean";
 }
 
 function sanitizeSettings(raw: unknown): CrewSettings {
@@ -52,12 +50,7 @@ function sanitizeSettings(raw: unknown): CrewSettings {
 	) {
 		out.defaultMaxTurns = r.defaultMaxTurns;
 	}
-	if (
-		typeof r.graceTurns === "number" &&
-		Number.isInteger(r.graceTurns) &&
-		r.graceTurns >= 1 &&
-		r.graceTurns <= GRACE_TURNS_CEILING
-	) {
+	if (typeof r.graceTurns === "number" && Number.isInteger(r.graceTurns) && r.graceTurns >= 1 && r.graceTurns <= GRACE_TURNS_CEILING) {
 		out.graceTurns = r.graceTurns;
 	}
 	if (typeof r.defaultJoinMode === "string" && VALID_JOIN_MODES.has(r.defaultJoinMode as JoinMode)) {
@@ -95,7 +88,10 @@ function readSettingsFile(filePath: string): CrewSettings {
 }
 
 export function loadCrewSettings(cwd: string = process.cwd()): CrewSettings {
-	return { ...readSettingsFile(globalPath()), ...readSettingsFile(projectPath(cwd)) };
+	return {
+		...readSettingsFile(globalPath()),
+		...readSettingsFile(projectPath(cwd)),
+	};
 }
 
 export function saveCrewSettings(s: CrewSettings, cwd: string = process.cwd()): boolean {
@@ -110,7 +106,15 @@ export function saveCrewSettings(s: CrewSettings, cwd: string = process.cwd()):
 }
 
 export function applyCrewSettingsToConfig(
-	config: { limits?: { maxConcurrentWorkers?: number }; runtime?: { maxTurns?: number; graceTurns?: number; groupJoin?: string }; notifierIntervalMs?: number },
+	config: {
+		limits?: { maxConcurrentWorkers?: number };
+		runtime?: {
+			maxTurns?: number;
+			graceTurns?: number;
+			groupJoin?: string;
+		};
+		notifierIntervalMs?: number;
+	},
 	settings: CrewSettings,
 ): void {
 	if (settings.maxConcurrent != null && config.limits) config.limits.maxConcurrentWorkers = settings.maxConcurrent;

package/src/runtime/sidechain-output.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { isSafePathId } from "../utils/safe-paths.ts";
 import { redactSecrets } from "../utils/redaction.ts";
+import { isSafePathId } from "../utils/safe-paths.ts";
 
 export interface SidechainEntry {
 	isSidechain: true;
@@ -14,7 +14,11 @@ export interface SidechainEntry {
 
 export function writeSidechainEntry(filePath: string, entry: Omit<SidechainEntry, "isSidechain" | "timestamp">): void {
 	fs.mkdirSync(path.dirname(filePath), { recursive: true });
-	fs.appendFileSync(filePath, `${JSON.stringify(redactSecrets({ isSidechain: true, timestamp: new Date().toISOString(), ...entry }))}\n`, "utf-8");
+	fs.appendFileSync(
+		filePath,
+		`${JSON.stringify(redactSecrets({ isSidechain: true, timestamp: new Date().toISOString(), ...entry }))}\n`,
+		"utf-8",
+	);
 }
 
 export function sidechainOutputPath(stateRoot: string, taskId: string): string {

package/src/runtime/single-agent-compose.ts

@@ -49,10 +49,7 @@ function orderSteps(steps: WorkflowStep[]): WorkflowStep[] {
  * The agent executes each phase in dependency order, writing outputs to the
  * named artifacts, mimicking what the multi-agent team would produce.
  */
-export function composeSingleAgentPrompt(
-	workflow: WorkflowConfig,
-	goal: string,
-): SingleAgentPrompt {
+export function composeSingleAgentPrompt(workflow: WorkflowConfig, goal: string): SingleAgentPrompt {
 	const ordered = orderSteps(workflow.steps);
 	const lines: string[] = [];
 	lines.push(`# Single-agent workflow execution: ${workflow.name}`);