pi-crew 0.2.2 → 0.2.3

package/src/runtime/async-runner.ts

@@ -11,6 +11,16 @@ export type FileExists = (filePath: string) => boolean;
 
 const requireFromHere = createRequire(import.meta.url);
 
+// Node introduced --experimental-strip-types in v22.6.0
+const STRIP_TYPES_MIN_MAJOR = 22;
+const STRIP_TYPES_MIN_MINOR = 6;
+
+export type LoaderSpec =
+	| { kind: "jiti"; path: string }
+	| { kind: "strip-types" };
+
+type LoaderInput = LoaderSpec | string | false | undefined;
+
 function packageRootFromRuntime(): string {
 	return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
 }
@@ -20,23 +30,87 @@ function jitiRegisterPathFromPackageJson(packageJsonPath: string): string {
 }
 
 export function resolveJitiRegisterPath(packageRoot = packageRootFromRuntime(), exists: FileExists = fs.existsSync): string | undefined {
-	const candidates = [
-		path.join(packageRoot, "node_modules", "jiti", "lib", "jiti-register.mjs"),
-		path.join(packageRoot, "..", "..", "node_modules", "jiti", "lib", "jiti-register.mjs"),
-	];
+	// Walk upward from packageRoot looking for node_modules/jiti/lib/jiti-register.mjs
+	let current = path.resolve(packageRoot);
+	const root = path.parse(current).root;
+	while (true) {
+		const candidate = path.join(current, "node_modules", "jiti", "lib", "jiti-register.mjs");
+		if (exists(candidate)) return candidate;
+		if (current === root) break;
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	// Fallback: require resolution (handles global installs or isolated stores)
 	try {
-		candidates.push(jitiRegisterPathFromPackageJson(requireFromHere.resolve("jiti/package.json")));
+		const pkgPath = requireFromHere.resolve("jiti/package.json");
+		const candidates = [
+			jitiRegisterPathFromPackageJson(pkgPath),
+			path.join(path.dirname(pkgPath), "register.mjs"),
+			path.join(path.dirname(pkgPath), "dist", "register.mjs"),
+		];
+		for (const c of candidates) if (exists(c)) return c;
 	} catch {
-		// Fall through to explicit candidate checks.
+		// Fall through.
 	}
-	return [...new Set(candidates)].find((candidate) => exists(candidate));
+	return undefined;
+}
+
+export function nodeSupportsStripTypes(version = process.version): boolean {
+	const match = /^v?(\d+)\.(\d+)/.exec(version);
+	if (!match) return false;
+	const major = Number(match[1]);
+	const minor = Number(match[2]);
+	if (major > STRIP_TYPES_MIN_MAJOR) return true;
+	if (major === STRIP_TYPES_MIN_MAJOR && minor >= STRIP_TYPES_MIN_MINOR) return true;
+	return false;
+}
+
+export interface ResolveLoaderOptions {
+	packageRoot?: string;
+	exists?: FileExists;
+	nodeVersion?: string;
 }
 
-export function getBackgroundRunnerCommand(runnerPath: string, cwd: string, runId: string, jitiRegisterPath: string | false | undefined = resolveJitiRegisterPath()): { args: string[]; loader: "jiti" } {
-	if (!jitiRegisterPath) throw new Error("pi-crew background runner cannot start: jiti loader not found. Reinstall pi-crew (`pi install npm:pi-crew`) or ensure node_modules/jiti is present.");
+export function resolveTypeScriptLoader(opts: ResolveLoaderOptions = {}): LoaderSpec | undefined {
+	const jitiPath = resolveJitiRegisterPath(opts.packageRoot, opts.exists);
+	if (jitiPath) return { kind: "jiti", path: jitiPath };
+	if (nodeSupportsStripTypes(opts.nodeVersion)) return { kind: "strip-types" };
+	return undefined;
+}
+
+function normalizeLoaderInput(input: LoaderInput): LoaderSpec | undefined {
+	if (input === undefined || input === null || input === false || input === "") return undefined;
+	if (typeof input === "string") return { kind: "jiti", path: input };
+	return input;
+}
+
+function buildLoaderUnavailableMessage(searchedFrom: string): string {
+	return [
+		"pi-crew background runner cannot start: jiti loader not found and Node --experimental-strip-types fallback unavailable.",
+		`  - Searched for node_modules/jiti walking upward from: ${searchedFrom}`,
+		`  - Node --experimental-strip-types requires >= 22.6 (current: ${process.version})`,
+		"  - Fix: run 'npm install' in the pi-crew directory, reinstall via 'pi install npm:pi-crew', or upgrade Node.js to >= 22.6.",
+	].join("\n");
+}
+
+export function getBackgroundRunnerCommand(
+	runnerPath: string,
+	cwd: string,
+	runId: string,
+	loaderInput: LoaderInput = resolveTypeScriptLoader(),
+): { args: string[]; loader: "jiti" | "strip-types" } {
+	const loader = normalizeLoaderInput(loaderInput);
+	if (!loader) throw new Error(buildLoaderUnavailableMessage(packageRootFromRuntime()));
+	if (loader.kind === "jiti") {
+		return {
+			args: ["--import", pathToFileURL(loader.path).href, runnerPath, "--cwd", cwd, "--run-id", runId],
+			loader: "jiti",
+		};
+	}
 	return {
-		args: ["--import", pathToFileURL(jitiRegisterPath).href, runnerPath, "--cwd", cwd, "--run-id", runId],
-		loader: "jiti",
+		args: ["--experimental-strip-types", runnerPath, "--cwd", cwd, "--run-id", runId],
+		loader: "strip-types",
 	};
 }
 
@@ -61,13 +135,13 @@ export function spawnBackgroundTeamRun(manifest: TeamRunManifest): SpawnBackgrou
 	fs.mkdirSync(manifest.stateRoot, { recursive: true });
 	const logFd = fs.openSync(logPath, "a");
 	try {
-		const jitiRegisterPath = resolveJitiRegisterPath();
-		if (!jitiRegisterPath) {
-			const message = "pi-crew background runner cannot start: jiti loader not found. Reinstall pi-crew (`pi install npm:pi-crew`) or ensure node_modules/jiti is present.";
+		const loader = resolveTypeScriptLoader();
+		if (!loader) {
+			const message = buildLoaderUnavailableMessage(packageRootFromRuntime());
 			appendEvent(manifest.eventsPath, { type: "async.failed", runId: manifest.runId, message });
 			throw new Error(message);
 		}
-		const command = getBackgroundRunnerCommand(runnerPath, manifest.cwd, manifest.runId, jitiRegisterPath);
+		const command = getBackgroundRunnerCommand(runnerPath, manifest.cwd, manifest.runId, loader);
 		fs.appendFileSync(logPath, `[pi-crew] background loader=${command.loader}\n`, "utf-8");
 		const child = spawn(process.execPath, command.args, buildBackgroundSpawnOptions(manifest, logFd));
 		child.unref();

package/src/runtime/background-runner.ts

@@ -10,6 +10,7 @@ import type { executeTeamRun as ExecuteTeamRunFn } from "./team-runner.ts";
 let _cachedExecuteTeamRun: typeof ExecuteTeamRunFn | undefined;
 async function executeTeamRun(...args: Parameters<typeof ExecuteTeamRunFn>): Promise<Awaited<ReturnType<typeof ExecuteTeamRunFn>>> {
 	if (!_cachedExecuteTeamRun) {
+		// LAZY: avoid pulling team-runner into background-runner at module load time.
 		const mod = await import("./team-runner.ts");
 		_cachedExecuteTeamRun = mod.executeTeamRun;
 	}

package/src/runtime/child-pi.ts

@@ -9,6 +9,7 @@ import { DEFAULT_CHILD_PI } from "../config/defaults.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { attachPostExitStdioGuard, trySignalChild } from "./post-exit-stdio-guard.ts";
 import { redactJsonLine, SECRET_KEY_PATTERN } from "../utils/redaction.ts";
+import { sanitizeEnvSecrets } from "../utils/env-filter.ts";
 
 const POST_EXIT_STDIO_GUARD_MS = DEFAULT_CHILD_PI.postExitStdioGuardMs;
 const FINAL_DRAIN_MS = DEFAULT_CHILD_PI.finalDrainMs;
@@ -111,10 +112,7 @@ export interface ChildPiRunResult {
 
 export function buildChildPiSpawnOptions(cwd: string, env: NodeJS.ProcessEnv): SpawnOptions {
 	// Filter out env vars whose keys match secret patterns to avoid leaking credentials to child processes
-	const filteredEnv: Record<string, string> = {};
-	for (const [key, value] of Object.entries(env)) {
-		if (value !== undefined && !SECRET_KEY_PATTERN.test(key)) filteredEnv[key] = value;
-	}
+	const filteredEnv = sanitizeEnvSecrets(env);
 	return {
 		cwd,
 		env: { ...filteredEnv, PI_CREW_PARENT_PID: String(process.pid) },

package/src/runtime/iteration-hooks.ts

@@ -6,6 +6,8 @@
  */
 import { spawn } from "node:child_process";
 import * as fs from "node:fs";
+import { resolveShellForScript } from "../utils/resolve-shell.ts";
+import { sanitizeEnvSecrets } from "../utils/env-filter.ts";
 import { DENIED_METRIC_NAMES } from "./metric-parser.ts";
 
 /** Hook execution stage. */
@@ -134,9 +136,10 @@ export async function runIterationHook(
 	const stderrChunks: Buffer[] = [];
 
 	return new Promise<HookResult>((resolve) => {
-		const child = spawn("bash", [hookScriptPath], {
+		const { command, args } = resolveShellForScript(hookScriptPath);
+		const child = spawn(command, args, {
 			cwd: payload.cwd,
-			env: { PATH: process.env.PATH ?? "/usr/bin:/bin", HOME: process.env.HOME ?? "/tmp", USER: process.env.USER, LANG: process.env.LANG, PI_CREW_HOOK: "1" },
+			env: { ...sanitizeEnvSecrets(process.env, { allowList: ["PATH", "HOME", "USER", "USERPROFILE", "TEMP", "TMP", "TMPDIR", "LANG", "LC_ALL", "ComSpec", "SystemRoot", "PI_*"] }), PI_CREW_HOOK: "1" },
 			stdio: ["pipe", "pipe", "pipe"],
 		});
 

package/src/runtime/live-session-runtime.ts

@@ -308,6 +308,7 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 	}
 	const availability = await isLiveSessionRuntimeAvailable();
 	if (!availability.available) return { available: true, exitCode: 1, stdout: "", stderr: availability.reason ?? "Live-session runtime unavailable.", jsonEvents: 0, error: availability.reason };
+	// LAZY: optional peer dependency — only loaded when live-session runtime is chosen.
 	const mod = await import("@mariozechner/pi-coding-agent") as LiveSessionModule;
 	if (typeof mod.createAgentSession !== "function") return { available: true, exitCode: 1, stdout: "", stderr: "createAgentSession export is unavailable.", jsonEvents: 0, error: "createAgentSession export is unavailable." };
 	let session: LiveSessionLike | undefined;

package/src/runtime/post-checks.ts

@@ -5,6 +5,8 @@
  * Distilled from pi-autoresearch's post-check / backpressure pattern.
  */
 import { execFileSync } from "node:child_process";
+import { resolveShellForScript } from "../utils/resolve-shell.ts";
+import { sanitizeEnvSecrets } from "../utils/env-filter.ts";
 
 /** Default timeout for post-check scripts (5 minutes). */
 const DEFAULT_TIMEOUT_MS = 300_000;
@@ -79,12 +81,13 @@ export async function runPostCheck(config: PostCheckConfig, cwd: string): Promis
 
 	return new Promise<PostCheckResult>((resolve) => {
 		try {
-			const output = execFileSync("bash", [scriptPath], {
+			const { command, args } = resolveShellForScript(scriptPath);
+		const output = execFileSync(command, args, {
 				cwd,
 				timeout: timeoutMs,
 				encoding: "utf-8",
 				maxBuffer: 10 * 1024 * 1024, // 10 MB
-				env: { PATH: process.env.PATH ?? "/usr/bin:/bin", HOME: process.env.HOME ?? "/tmp", USER: process.env.USER, LANG: process.env.LANG, PI_CREW_POST_CHECK: "1" },
+				env: { ...sanitizeEnvSecrets(process.env, { allowList: ["PATH", "HOME", "USER", "USERPROFILE", "TEMP", "TMP", "TMPDIR", "LANG", "LC_ALL", "ComSpec", "SystemRoot", "PI_*"] }), PI_CREW_POST_CHECK: "1" },
 			});
 
 			const durationMs = Date.now() - startTime;

package/src/runtime/runtime-resolver.ts

@@ -37,6 +37,7 @@ export async function isLiveSessionRuntimeAvailable(timeoutMs = 1500, env: NodeJ
 	}
 	const probe = async (): Promise<{ available: boolean; reason?: string }> => {
 		try {
+			// LAZY: optional peer dependency — probe at runtime to avoid hard dependency.
 			const mod = await import("@mariozechner/pi-coding-agent");
 			const api = mod as Record<string, unknown>;
 			const required = ["createAgentSession", "DefaultResourceLoader", "SessionManager", "SettingsManager"];

package/src/runtime/subagent-manager.ts

@@ -58,7 +58,12 @@ interface QueuedSpawn {
 	signal?: AbortSignal;
 }
 
+function isValidSubagentId(id: string): boolean {
+	return /^[a-z0-9_]+$/i.test(id) && id.length <= 128;
+}
+
 function persistedSubagentPath(cwd: string, id: string): string {
+	if (!isValidSubagentId(id)) throw new Error(`Invalid subagent id: ${id}`);
 	return path.join(projectCrewRoot(cwd), DEFAULT_PATHS.state.subagentsSubdir, `${id}.json`);
 }
 

package/src/runtime/task-runner.ts

@@ -291,6 +291,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		tasks = updateTask(tasks, task);
 		({ task, tasks } = checkpointTask(manifest, tasks, task, "artifact-written"));
 	} else if (runtimeKind === "live-session") {
+		// LAZY: live-executor is only needed for live-session runtime branches.
 		const { runLiveTask } = await import("./task-runner/live-executor.ts");
 		const live = await runLiveTask({ manifest, tasks, task, step: input.step, agent: input.agent, prompt, signal: input.signal, runtimeConfig: input.runtimeConfig, parentContext: input.parentContext, parentModel: input.parentModel, modelRegistry: input.modelRegistry, modelOverride: input.modelOverride, teamRoleModel: input.teamRoleModel });
 		task = live.task;

package/src/runtime/yield-handler.ts

@@ -6,6 +6,7 @@ import { subprocessToolRegistry, type SubprocessToolEvent } from "./subprocess-t
 let _ajv: Awaited<ReturnType<typeof getAjvInternal>> | null | undefined;
 
 async function getAjvInternal() {
+	// LAZY: AJV is an optional heavy validator — only load on first use.
 	const mod = await import("ajv");
 	const AjvCtor = ("default" in mod ? (mod as Record<string, unknown>).default : mod) as unknown as new (opts: Record<string, unknown>) => { compile: (schema: unknown) => { (data: unknown): boolean; errors?: unknown[] }; errorsText: (errors?: unknown[]) => string };
 	return new AjvCtor({ allErrors: true, strict: false, logger: false });

package/src/schema/team-tool-schema.ts

@@ -24,6 +24,7 @@ export const TeamToolParams = Type.Object({
 		Type.Literal("list"),
 		Type.Literal("get"),
 		Type.Literal("cancel"),
+		Type.Literal("retry"),
 		Type.Literal("resume"),
 		Type.Literal("respond"),
 		Type.Literal("create"),

package/src/state/artifact-store.ts

@@ -112,10 +112,10 @@ export function writeArtifact(artifactsRoot: string, options: ArtifactWriteOptio
 	resolveRealContainedPath(path.dirname(artifactsRoot), path.basename(artifactsRoot));
 	fs.mkdirSync(path.dirname(filePath), { recursive: true });
 	resolveRealContainedPath(artifactsRoot, path.dirname(filePath));
-	// Compute hash on original content for integrity verification.
-	const contentHash = hashContent(options.content);
 	const content = redactSecretString(options.content);
 	atomicWriteFile(filePath, content);
+	// Compute hash on written bytes for integrity verification.
+	const contentHash = hashContent(content);
 	const stats = fs.statSync(filePath);
 	return {
 		kind: options.kind,

package/src/state/atomic-write.ts

@@ -51,7 +51,7 @@ function isRetryableRenameError(error: unknown): boolean {
 	return Boolean(error && typeof error === "object" && "code" in error && RETRYABLE_RENAME_CODES.has(String((error as NodeJS.ErrnoException).code)));
 }
 
-export function __test__renameWithRetry(tempPath: string, filePath: string, retries = 10, rename: (oldPath: string, newPath: string) => void = fs.renameSync): void {
+export function renameWithRetry(tempPath: string, filePath: string, retries = 10, rename: (oldPath: string, newPath: string) => void = fs.renameSync): void {
 	let lastError: unknown;
 	for (let attempt = 0; attempt <= retries; attempt++) {
 		try {
@@ -68,7 +68,10 @@ export function __test__renameWithRetry(tempPath: string, filePath: string, retr
 	throw lastError;
 }
 
-export async function __test__renameWithRetryAsync(tempPath: string, filePath: string, retries = 10, rename: (oldPath: string, newPath: string) => Promise<void> = (source, destination) => fs.promises.rename(source, destination)): Promise<void> {
+/** Test alias for renameWithRetry. */
+export const __test__renameWithRetry = renameWithRetry;
+
+export async function renameWithRetryAsync(tempPath: string, filePath: string, retries = 10, rename: (oldPath: string, newPath: string) => Promise<void> = (source, destination) => fs.promises.rename(source, destination)): Promise<void> {
 	let lastError: unknown;
 	for (let attempt = 0; attempt <= retries; attempt++) {
 		try {
@@ -83,6 +86,9 @@ export async function __test__renameWithRetryAsync(tempPath: string, filePath: s
 	throw lastError;
 }
 
+/** Test alias for renameWithRetryAsync. */
+export const __test__renameWithRetryAsync = renameWithRetryAsync;
+
 export function atomicWriteFile(filePath: string, content: string): void {
 	if (!isSymlinkSafePath(filePath)) throw new Error(`Refusing to write: target is a symlink or inside untrusted directory: ${filePath}`);
 	fs.mkdirSync(path.dirname(filePath), { recursive: true });
@@ -99,8 +105,19 @@ export function atomicWriteFile(filePath: string, content: string): void {
 		}
 		fs.writeSync(fd, content, undefined, "utf-8");
 		fs.closeSync(fd);
-		__test__renameWithRetry(tempPath, filePath);
+		renameWithRetry(tempPath, filePath);
 	} catch (error) {
+		let matches = false;
+		try {
+			const existing = fs.readFileSync(filePath, "utf-8");
+			matches = existing === content;
+		} catch {
+			/* ignore */
+		}
+		if (matches) {
+			try { fs.rmSync(tempPath, { force: true }); } catch { /* best-effort */ }
+			return;
+		}
 		try {
 			fs.rmSync(tempPath, { force: true });
 		} catch (cleanupError) {
@@ -127,7 +144,7 @@ export async function atomicWriteFileAsync(filePath: string, content: string): P
 		await fd.writeFile(content, "utf-8");
 		await fd.close();
 		try {
-			await __test__renameWithRetryAsync(tempPath, filePath);
+			await renameWithRetryAsync(tempPath, filePath);
 		} catch (renameError) {
 			let matches = false;
 			try {

package/src/state/event-log.ts

@@ -7,6 +7,7 @@ import { emitFromTeamEvent } from "../ui/run-event-bus.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { readJsonlSince, type IncrementalReadState } from "../utils/incremental-reader.ts";
 import { redactSecrets } from "../utils/redaction.ts";
+import { sleepSync } from "../utils/sleep.ts";
 import { needsRotation, compactEventLog } from "./event-log-rotation.ts";
 
 export type TeamEventProvenance = "live_worker" | "test" | "healthcheck" | "replay" | "api" | "background" | "team_runner";
@@ -57,8 +58,65 @@ const TERMINAL_EVENT_TYPES = new Set<string>(DEFAULT_EVENT_LOG.terminalEventType
 const MAX_EVENTS_BYTES = 50 * 1024 * 1024;
 
 const sequenceCache = new Map<string, { size: number; mtimeMs: number; seq: number }>();
+const MAX_SEQUENCE_CACHE_ENTRIES = 256;
 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.
+ */
+function withEventLogLockSync<T>(eventsPath: string, fn: () => T): T {
+	const lockDir = `${eventsPath}.lock`;
+	const pidFile = path.join(lockDir, "pid");
+	const start = Date.now();
+	const timeout = 5000;
+	const staleMs = 10000;
+	let acquired = false;
+	while (true) {
+		try {
+			fs.mkdirSync(lockDir);
+			try { fs.writeFileSync(pidFile, String(process.pid), "utf-8"); } catch { /* best-effort */ }
+			acquired = true;
+			break;
+		} catch {
+			if (Date.now() - start > timeout) {
+				logInternalError("event-log.lock-timeout", new Error(`Event log lock timeout for ${eventsPath}`), `lockDir=${lockDir}`);
+				break;
+			}
+			// Stale detection: if the owning process is dead, remove the stale lock.
+			try {
+				const raw = fs.readFileSync(pidFile, "utf-8").trim();
+				const ownerPid = Number.parseInt(raw, 10);
+				if (!Number.isNaN(ownerPid) && ownerPid !== process.pid) {
+					let alive = false;
+					try { process.kill(ownerPid, 0); alive = true; } catch { /* dead */ }
+					if (!alive) {
+						try {
+							const stat = fs.statSync(lockDir);
+							if (Date.now() - stat.mtimeMs > staleMs) {
+								fs.rmSync(lockDir, { recursive: true, force: true });
+								continue;
+							}
+						} catch { /* race — let loop sleep */ }
+					}
+				}
+			} catch { /* no pid file — fall through to sleep */ }
+			sleepSync(10);
+		}
+	}
+	try {
+		return fn();
+	} finally {
+		if (acquired) {
+			try { fs.rmSync(lockDir, { recursive: true, force: true }); } catch { /* best-effort */ }
+		}
+	}
+}
+
+function evictOldestSequenceCacheEntry(): void {
+	const first = sequenceCache.keys().next().value;
+	if (first !== undefined) sequenceCache.delete(first);
+}
+
 export function sequencePath(eventsPath: string): string {
 	return `${eventsPath}.seq`;
 }
@@ -117,54 +175,59 @@ export function computeEventFingerprint(event: Pick<TeamEvent, "type" | "runId"
 }
 
 export function appendEvent(eventsPath: string, event: AppendTeamEvent): TeamEvent {
-	fs.mkdirSync(path.dirname(eventsPath), { recursive: true });
-	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;
-	}
-	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`), `eventsPath=${eventsPath}`);
-			return { ...fullEvent, metadata: { ...(fullEvent.metadata ?? { seq: 0, provenance: "team_runner" }), appended: false } };
+	return withEventLogLockSync(eventsPath, () => {
+		fs.mkdirSync(path.dirname(eventsPath), { recursive: true });
+		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;
 		}
-	} catch (error) {
-		logInternalError("event-log.size-check", error, `eventsPath=${eventsPath}`);
-	}
-	fs.appendFileSync(eventsPath, `${JSON.stringify(redactSecrets(fullEvent))}\n`, "utf-8");
-	appendCounter++;
-	if (appendCounter % 100 === 0 && needsRotation(eventsPath)) {
-		try { compactEventLog(eventsPath); } catch (error) { logInternalError("event-log.rotation", error, `eventsPath=${eventsPath}`); }
-	}
-	// Emit to UI event bus for event-first delivery
-	try { emitFromTeamEvent(fullEvent); } catch (error) { logInternalError("event-log.emit", error); }
-	const seq = fullEvent.metadata?.seq ?? 0;
-	try {
-		const stat = fs.statSync(eventsPath);
-		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;
+		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`), `eventsPath=${eventsPath}`);
+				return { ...fullEvent, metadata: { ...(fullEvent.metadata ?? { seq: 0, provenance: "team_runner" }), appended: false } };
+			}
+		} catch (error) {
+			logInternalError("event-log.size-check", error, `eventsPath=${eventsPath}`);
+		}
+		fs.appendFileSync(eventsPath, `${JSON.stringify(redactSecrets(fullEvent))}\n`, "utf-8");
+		appendCounter++;
+		if (appendCounter % 100 === 0 && needsRotation(eventsPath)) {
+			try { compactEventLog(eventsPath); } catch (error) { logInternalError("event-log.rotation", error, `eventsPath=${eventsPath}`); }
+		}
+		// Emit to UI event bus for event-first delivery
+		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) {
+				evictOldestSequenceCacheEntry();
+			}
+			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;
+	});
 }
 
 export function readEvents(eventsPath: string): TeamEvent[] {

package/src/state/locks.ts

@@ -40,16 +40,6 @@ function isLockStale(filePath: string, staleMs: number): boolean {
 	}
 }
 
-function readLockState(filePath: string, staleMs: number): boolean {
-	if (!isLockStale(filePath, staleMs)) return false;
-	try {
-		fs.rmSync(filePath, { force: true });
-		return true;
-	} catch {
-		return false;
-	}
-}
-
 function writeLockFile(filePath: string): void {
 	const fd = fs.openSync(filePath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 0o644);
 	try {
@@ -69,14 +59,18 @@ function acquireLockWithRetry(filePath: string, staleMs: number): void {
 		} catch (error) {
 			const code = (error as NodeJS.ErrnoException).code;
 			if (code !== "EEXIST") throw error;
-			if (!readLockState(filePath, staleMs)) {
+			if (Date.now() > deadline) {
 				throw new Error(`Run '${path.basename(filePath)}' is locked by another operation.`);
 			}
-			if (Date.now() > deadline) {
+			// If lock is not stale, fail fast (sync should not wait for active locks)
+			if (!isLockStale(filePath, staleMs)) {
 				throw new Error(`Run '${path.basename(filePath)}' is locked by another operation.`);
 			}
-			const delay = Math.min(250, 25 * 2 ** attempt);
-			sleepSync(delay);
+			// Lock is stale — try to clear it, but don't bail on rmSync error — let loop retry
+			try {
+				fs.rmSync(filePath, { force: true });
+			} catch { /* race — let loop retry */ }
+			sleepSync(Math.min(250, 25 * 2 ** attempt));
 			attempt++;
 		}
 	}
@@ -107,6 +101,10 @@ async function acquireLockWithRetryAsync(filePath: string, staleMs: number): Pro
 			if (Date.now() > deadline) {
 				throw new Error(`Run '${path.basename(filePath)}' is locked by another operation.`);
 			}
+			// If lock is not stale, fail fast (async should not wait for active locks)
+			if (!isLockStale(filePath, staleMs)) {
+				throw new Error(`Run '${path.basename(filePath)}' is locked by another operation.`);
+			}
 			readLockStateAsync(filePath, staleMs);
 			const delay = Math.min(250, 25 * 2 ** attempt);
 			await sleep(delay);

package/src/ui/run-action-dispatcher.ts

@@ -5,6 +5,7 @@ import type { handleTeamTool as HandleTeamToolFn } from "../extension/team-tool.
 let _cachedHandleTeamTool: typeof HandleTeamToolFn | undefined;
 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("../extension/team-tool.ts");
 		_cachedHandleTeamTool = mod.handleTeamTool;
 	}

package/src/utils/env-filter.ts

@@ -0,0 +1,30 @@
+import { SECRET_KEY_PATTERN } from "./redaction.ts";
+
+export interface SanitizeEnvOptions {
+	/** Allow-list of env var names to preserve. Supports trailing glob, e.g. `"PI_*"`. */
+	allowList?: string[];
+}
+
+/**
+ * Strip env vars whose keys look like secrets before passing to child processes.
+ *
+ * Default mode (no allowList): deny-list using SECRET_KEY_PATTERN.
+ * When allowList is provided, only keys matching the allow-list are preserved.
+ */
+export function sanitizeEnvSecrets(env: NodeJS.ProcessEnv, options?: SanitizeEnvOptions): Record<string, string> {
+	const filtered: Record<string, string> = {};
+	if (options?.allowList && options.allowList.length > 0) {
+		const matchers = options.allowList.map((p) => {
+			if (p.endsWith("*")) return (k: string) => k.startsWith(p.slice(0, -1));
+			return (k: string) => k === p;
+		});
+		for (const [key, value] of Object.entries(env)) {
+			if (value !== undefined && matchers.some((fn) => fn(key))) filtered[key] = value;
+		}
+		return filtered;
+	}
+	for (const [key, value] of Object.entries(env)) {
+		if (value !== undefined && !SECRET_KEY_PATTERN.test(key)) filtered[key] = value;
+	}
+	return filtered;
+}

package/src/utils/redaction.ts

@@ -2,7 +2,7 @@ export const SECRET_KEY_PATTERN = /(?:^|[_.-])(token|api[-_]?key|password|passwd
 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;
+const PEM_PRIVATE_KEY_PATTERN = /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]{0,65536}?-----END [A-Z ]*PRIVATE KEY-----/g;
 
 function isRecord(value: unknown): value is Record<string, unknown> {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return false;