pi-crew 0.1.41 → 0.1.44

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

@@ -1,109 +1,115 @@
-import { Type } from "typebox";
-
-const SkillOverride = Type.Unsafe({
-	description: "Skill name(s) to inject, array of skill names, or false to disable role defaults.",
-	anyOf: [
-		{ type: "string" },
-		{ type: "array", items: { type: "string" } },
-		{ type: "boolean" },
-	],
-});
-
-const FreeformConfig = Type.Unsafe({
-	description: "Resource config for management actions.",
-	type: "object",
-	additionalProperties: true,
-});
-
-export const TeamToolParams = Type.Object({
-	action: Type.Optional(Type.Union([
-		Type.Literal("run"),
-		Type.Literal("plan"),
-		Type.Literal("status"),
-		Type.Literal("list"),
-		Type.Literal("get"),
-		Type.Literal("cancel"),
-		Type.Literal("resume"),
-		Type.Literal("create"),
-		Type.Literal("update"),
-		Type.Literal("delete"),
-		Type.Literal("doctor"),
-		Type.Literal("cleanup"),
-		Type.Literal("events"),
-		Type.Literal("artifacts"),
-		Type.Literal("worktrees"),
-		Type.Literal("forget"),
-		Type.Literal("summary"),
-		Type.Literal("prune"),
-		Type.Literal("export"),
-		Type.Literal("import"),
-		Type.Literal("imports"),
-		Type.Literal("help"),
-		Type.Literal("validate"),
-		Type.Literal("config"),
-		Type.Literal("init"),
-		Type.Literal("recommend"),
-		Type.Literal("autonomy"),
-		Type.Literal("api"),
-	], { description: "Team action. Defaults to 'list' when omitted." })),
-	resource: Type.Optional(Type.Union([
-		Type.Literal("agent"),
-		Type.Literal("team"),
-		Type.Literal("workflow"),
-	], { description: "Resource kind for get/create/update/delete/list. Defaults to all for list." })),
-	team: Type.Optional(Type.String({ description: "Team name, e.g. default or implementation." })),
-	workflow: Type.Optional(Type.String({ description: "Workflow name, e.g. default or review." })),
-	role: Type.Optional(Type.String({ description: "Role name to run directly within a team." })),
-	agent: Type.Optional(Type.String({ description: "Agent name to inspect or run directly." })),
-	goal: Type.Optional(Type.String({ description: "High-level objective for a team run." })),
-	task: Type.Optional(Type.String({ description: "Concrete task text for direct role/agent execution." })),
-	runId: Type.Optional(Type.String({ description: "Run ID for status, cancel, or resume." })),
-	async: Type.Optional(Type.Boolean({ description: "Run in background when execution support is enabled." })),
-	workspaceMode: Type.Optional(Type.Union([
-		Type.Literal("single"),
-		Type.Literal("worktree"),
-	], { description: "Workspace isolation mode. Worktree mode is planned after MVP." })),
-	context: Type.Optional(Type.Union([
-		Type.Literal("fresh"),
-		Type.Literal("fork"),
-	], { description: "Child context mode for workers." })),
-	cwd: Type.Optional(Type.String({ description: "Working directory override." })),
-	model: Type.Optional(Type.String({ description: "Model override for direct runs." })),
-	skill: Type.Optional(SkillOverride),
-	scope: Type.Optional(Type.Union([
-		Type.Literal("user"),
-		Type.Literal("project"),
-		Type.Literal("both"),
-	], { description: "Resource scope for discovery or management." })),
-	config: Type.Optional(FreeformConfig),
-	dryRun: Type.Optional(Type.Boolean({ description: "Preview a management mutation without writing files." })),
-	confirm: Type.Optional(Type.Boolean({ description: "Required for destructive management actions." })),
-	force: Type.Optional(Type.Boolean({ description: "Override reference checks for destructive management actions." })),
-	keep: Type.Optional(Type.Integer({ minimum: 0, description: "Number of finished runs to keep for prune." })),
-	updateReferences: Type.Optional(Type.Boolean({ description: "When renaming agents or workflows, update team references in the same project/user scope." })),
-});
-
-export interface TeamToolParamsValue {
-	action?: "run" | "plan" | "status" | "list" | "get" | "cancel" | "resume" | "create" | "update" | "delete" | "doctor" | "cleanup" | "events" | "artifacts" | "worktrees" | "forget" | "summary" | "prune" | "export" | "import" | "imports" | "help" | "validate" | "config" | "init" | "recommend" | "autonomy" | "api";
-	resource?: "agent" | "team" | "workflow";
-	team?: string;
-	workflow?: string;
-	role?: string;
-	agent?: string;
-	goal?: string;
-	task?: string;
-	runId?: string;
-	async?: boolean;
-	workspaceMode?: "single" | "worktree";
-	context?: "fresh" | "fork";
-	cwd?: string;
-	model?: string;
-	skill?: string | string[] | boolean;
-	scope?: "user" | "project" | "both";
-	config?: unknown;
-	dryRun?: boolean;
-	confirm?: boolean;
-	force?: boolean;
-	keep?: number;
-	updateReferences?: boolean;
-}
+import { Type } from "typebox";
+
+const SkillOverride = Type.Unsafe({
+	description: "Skill name(s) to inject, array of skill names, or false to disable role defaults.",
+	anyOf: [
+		{ type: "string" },
+		{ type: "array", items: { type: "string" } },
+		{ type: "boolean" },
+	],
+});
+
+const FreeformConfig = Type.Unsafe({
+	description: "Resource config for management actions.",
+	type: "object",
+	additionalProperties: true,
+});
+
+export const TeamToolParams = Type.Object({
+	action: Type.Optional(Type.Union([
+		Type.Literal("run"),
+		Type.Literal("plan"),
+		Type.Literal("status"),
+		Type.Literal("list"),
+		Type.Literal("get"),
+		Type.Literal("cancel"),
+		Type.Literal("resume"),
+		Type.Literal("respond"),
+		Type.Literal("create"),
+		Type.Literal("update"),
+		Type.Literal("delete"),
+		Type.Literal("doctor"),
+		Type.Literal("cleanup"),
+		Type.Literal("events"),
+		Type.Literal("artifacts"),
+		Type.Literal("worktrees"),
+		Type.Literal("forget"),
+		Type.Literal("summary"),
+		Type.Literal("prune"),
+		Type.Literal("export"),
+		Type.Literal("import"),
+		Type.Literal("imports"),
+		Type.Literal("help"),
+		Type.Literal("validate"),
+		Type.Literal("config"),
+		Type.Literal("init"),
+		Type.Literal("recommend"),
+		Type.Literal("autonomy"),
+		Type.Literal("api"),
+		Type.Literal("settings"),
+	], { description: "Team action. Defaults to 'list' when omitted." })),
+	resource: Type.Optional(Type.Union([
+		Type.Literal("agent"),
+		Type.Literal("team"),
+		Type.Literal("workflow"),
+	], { description: "Resource kind for get/create/update/delete/list. Defaults to all for list." })),
+	team: Type.Optional(Type.String({ description: "Team name, e.g. default or implementation." })),
+	workflow: Type.Optional(Type.String({ description: "Workflow name, e.g. default or review." })),
+	role: Type.Optional(Type.String({ description: "Role name to run directly within a team." })),
+	agent: Type.Optional(Type.String({ description: "Agent name to inspect or run directly." })),
+	goal: Type.Optional(Type.String({ description: "High-level objective for a team run." })),
+	task: Type.Optional(Type.String({ description: "Concrete task text for direct role/agent execution." })),
+	runId: Type.Optional(Type.String({ description: "Run ID for status, cancel, or resume." })),
+	taskId: Type.Optional(Type.String({ description: "Task ID for respond action." })),
+	message: Type.Optional(Type.String({ description: "Message for respond action." })),
+	async: Type.Optional(Type.Boolean({ description: "Run in background when execution support is enabled." })),
+	workspaceMode: Type.Optional(Type.Union([
+		Type.Literal("single"),
+		Type.Literal("worktree"),
+	], { description: "Workspace isolation mode. Worktree mode is planned after MVP." })),
+	context: Type.Optional(Type.Union([
+		Type.Literal("fresh"),
+		Type.Literal("fork"),
+	], { description: "Child context mode for workers." })),
+	cwd: Type.Optional(Type.String({ description: "Working directory override." })),
+	model: Type.Optional(Type.String({ description: "Model override for direct runs." })),
+	skill: Type.Optional(SkillOverride),
+	scope: Type.Optional(Type.Union([
+		Type.Literal("user"),
+		Type.Literal("project"),
+		Type.Literal("both"),
+	], { description: "Resource scope for discovery or management." })),
+	config: Type.Optional(FreeformConfig),
+	dryRun: Type.Optional(Type.Boolean({ description: "Preview a management mutation without writing files." })),
+	confirm: Type.Optional(Type.Boolean({ description: "Required for destructive management actions." })),
+	force: Type.Optional(Type.Boolean({ description: "Override reference checks for destructive management actions." })),
+	keep: Type.Optional(Type.Integer({ minimum: 0, description: "Number of finished runs to keep for prune." })),
+	updateReferences: Type.Optional(Type.Boolean({ description: "When renaming agents or workflows, update team references in the same project/user scope." })),
+});
+
+export interface TeamToolParamsValue {
+	action?: "run" | "plan" | "status" | "list" | "get" | "cancel" | "resume" | "respond" | "create" | "update" | "delete" | "doctor" | "cleanup" | "events" | "artifacts" | "worktrees" | "forget" | "summary" | "prune" | "export" | "import" | "imports" | "help" | "validate" | "config" | "init" | "recommend" | "autonomy" | "api" | "settings";
+	resource?: "agent" | "team" | "workflow";
+	team?: string;
+	workflow?: string;
+	role?: string;
+	agent?: string;
+	goal?: string;
+	task?: string;
+	runId?: string;
+	taskId?: string;
+	message?: string;
+	async?: boolean;
+	workspaceMode?: "single" | "worktree";
+	context?: "fresh" | "fork";
+	cwd?: string;
+	model?: string;
+	skill?: string | string[] | boolean;
+	scope?: "user" | "project" | "both";
+	config?: Record<string, unknown>;
+	dryRun?: boolean;
+	confirm?: boolean;
+	force?: boolean;
+	keep?: number;
+	updateReferences?: boolean;
+}

package/src/state/artifact-store.ts

@@ -105,10 +105,12 @@ function resolveInside(baseDir: string, relativePath: string): string {
 export function writeArtifact(artifactsRoot: string, options: ArtifactWriteOptions): ArtifactDescriptor {
 	const filePath = resolveInside(artifactsRoot, options.relativePath);
 	fs.mkdirSync(artifactsRoot, { recursive: true });
-	if (fs.lstatSync(artifactsRoot).isSymbolicLink()) throw new Error(`Path is outside ${path.dirname(artifactsRoot)}: ${artifactsRoot}`);
+	if (fs.lstatSync(artifactsRoot).isSymbolicLink()) throw new Error(`Artifacts root is a symbolic link — not allowed: ${artifactsRoot}`);
 	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);
 	const stats = fs.statSync(filePath);
@@ -118,7 +120,7 @@ export function writeArtifact(artifactsRoot: string, options: ArtifactWriteOptio
 		createdAt: new Date().toISOString(),
 		producer: options.producer,
 		sizeBytes: stats.size,
-		contentHash: hashContent(content),
+		contentHash,
 		retention: options.retention ?? "run",
 	};
 }

package/src/state/atomic-write.ts

@@ -5,8 +5,16 @@ import { logInternalError } from "../utils/internal-error.ts";
 const RETRYABLE_RENAME_CODES = new Set(["EPERM", "EBUSY", "EACCES"]);
 
 function sleepSync(ms: number): void {
-	const buffer = new SharedArrayBuffer(4);
-	Atomics.wait(new Int32Array(buffer), 0, 0, ms);
+	try {
+		const buffer = new SharedArrayBuffer(4);
+		Atomics.wait(new Int32Array(buffer), 0, 0, ms);
+	} catch {
+		// Fallback for environments without SharedArrayBuffer / Atomics.wait support.
+		const deadline = Date.now() + ms;
+		while (Date.now() < deadline) {
+			// Busy-wait — only used as last-resort, retry counts are capped.
+		}
+	}
 }
 
 function sleep(ms: number): Promise<void> {
@@ -17,7 +25,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 = 20, rename: (oldPath: string, newPath: string) => void = fs.renameSync): void {
+export function __test__renameWithRetry(tempPath: string, filePath: string, retries = 5, rename: (oldPath: string, newPath: string) => void = fs.renameSync): void {
 	let lastError: unknown;
 	for (let attempt = 0; attempt <= retries; attempt++) {
 		try {
@@ -32,7 +40,7 @@ export function __test__renameWithRetry(tempPath: string, filePath: string, retr
 	throw lastError;
 }
 
-export async function __test__renameWithRetryAsync(tempPath: string, filePath: string, retries = 20, rename: (oldPath: string, newPath: string) => Promise<void> = (source, destination) => fs.promises.rename(source, destination)): Promise<void> {
+export async function __test__renameWithRetryAsync(tempPath: string, filePath: string, retries = 5, 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 {

package/src/state/contracts.ts

@@ -1,105 +1,109 @@
-export const TEAM_RUN_STATUSES = ["queued", "planning", "running", "blocked", "completed", "failed", "cancelled"] as const;
-export type TeamRunStatus = typeof TEAM_RUN_STATUSES[number];
-
-export const TEAM_TASK_STATUSES = ["queued", "running", "completed", "failed", "cancelled", "skipped"] as const;
-export type TeamTaskStatus = typeof TEAM_TASK_STATUSES[number];
-
-export const TEAM_TERMINAL_RUN_STATUSES: ReadonlySet<TeamRunStatus> = new Set(["blocked", "completed", "failed", "cancelled"]);
-export const TEAM_TERMINAL_TASK_STATUSES: ReadonlySet<TeamTaskStatus> = new Set(["completed", "failed", "cancelled", "skipped"]);
-
-export const TEAM_RUN_STATUS_TRANSITIONS: Readonly<Record<TeamRunStatus, readonly TeamRunStatus[]>> = {
-	queued: ["planning", "running", "cancelled", "failed"],
-	planning: ["running", "blocked", "cancelled", "failed"],
-	running: ["blocked", "completed", "failed", "cancelled"],
-	blocked: ["running", "cancelled", "failed"],
-	completed: ["running", "cancelled"],
-	failed: ["running", "cancelled"],
-	cancelled: ["running"],
-};
-
-export const TEAM_TASK_STATUS_TRANSITIONS: Readonly<Record<TeamTaskStatus, readonly TeamTaskStatus[]>> = {
-	queued: ["running", "cancelled", "skipped", "failed"],
-	running: ["completed", "failed", "cancelled", "queued"],
-	completed: ["queued"],
-	failed: ["queued", "cancelled"],
-	cancelled: ["queued"],
-	skipped: ["queued", "cancelled"],
-};
-
-export const TEAM_EVENT_TYPES = [
-	"run.created",
-	"run.queued",
-	"run.planning",
-	"run.running",
-	"run.blocked",
-	"run.completed",
-	"run.failed",
-	"run.cancelled",
-	"task.started",
-	"task.progress",
-	"task.blocked",
-	"task.green",
-	"task.red",
-	"task.completed",
-	"task.failed",
-	"task.cancelled",
-	"task.skipped",
-	"review.approved",
-	"review.rejected",
-	"policy.action",
-	"policy.escalated",
-	"recovery.attempted",
-	"recovery.escalated",
-	"branch.stale",
-	"mailbox.timeout",
-	"worktree.cleanup",
-	"worktree.dirty",
-	"async.spawned",
-	"async.started",
-	"async.completed",
-	"async.failed",
-	"async.stale",
-] as const;
-export type TeamEventType = typeof TEAM_EVENT_TYPES[number];
-
-export const TEAM_WAKEABLE_EVENT_TYPES: ReadonlySet<TeamEventType> = new Set([
-	"run.blocked",
-	"run.completed",
-	"run.failed",
-	"run.cancelled",
-	"task.completed",
-	"task.failed",
-	"task.cancelled",
-	"task.skipped",
-	"async.completed",
-	"async.failed",
-	"async.stale",
-]);
-
-export function isTeamRunStatus(value: unknown): value is TeamRunStatus {
-	return typeof value === "string" && TEAM_RUN_STATUSES.includes(value as TeamRunStatus);
-}
-
-export function isTeamTaskStatus(value: unknown): value is TeamTaskStatus {
-	return typeof value === "string" && TEAM_TASK_STATUSES.includes(value as TeamTaskStatus);
-}
-
-export function isTerminalRunStatus(status: TeamRunStatus): boolean {
-	return TEAM_TERMINAL_RUN_STATUSES.has(status);
-}
-
-export function isTerminalTaskStatus(status: TeamTaskStatus): boolean {
-	return TEAM_TERMINAL_TASK_STATUSES.has(status);
-}
-
-export function canTransitionRunStatus(from: TeamRunStatus, to: TeamRunStatus): boolean {
-	return from === to || (TEAM_RUN_STATUS_TRANSITIONS[from]?.includes(to) ?? false);
-}
-
-export function canTransitionTaskStatus(from: TeamTaskStatus, to: TeamTaskStatus): boolean {
-	return from === to || (TEAM_TASK_STATUS_TRANSITIONS[from]?.includes(to) ?? false);
-}
-
-export function isWakeableTeamEventType(type: TeamEventType): boolean {
-	return TEAM_WAKEABLE_EVENT_TYPES.has(type);
-}
+export const TEAM_RUN_STATUSES = ["queued", "planning", "running", "blocked", "completed", "failed", "cancelled"] as const;
+export type TeamRunStatus = typeof TEAM_RUN_STATUSES[number];
+
+export const TEAM_TASK_STATUSES = ["queued", "running", "waiting", "completed", "failed", "cancelled", "skipped"] as const;
+export type TeamTaskStatus = typeof TEAM_TASK_STATUSES[number];
+
+export const TEAM_TERMINAL_RUN_STATUSES: ReadonlySet<TeamRunStatus> = new Set(["blocked", "completed", "failed", "cancelled"]);
+export const TEAM_TERMINAL_TASK_STATUSES: ReadonlySet<TeamTaskStatus> = new Set(["completed", "failed", "cancelled", "skipped"]);
+
+export const TEAM_RUN_STATUS_TRANSITIONS: Readonly<Record<TeamRunStatus, readonly TeamRunStatus[]>> = {
+	queued: ["planning", "running", "cancelled", "failed"],
+	planning: ["running", "blocked", "cancelled", "failed"],
+	running: ["blocked", "completed", "failed", "cancelled"],
+	blocked: ["running", "cancelled", "failed"],
+	completed: ["running", "cancelled"],
+	failed: ["running", "cancelled"],
+	cancelled: ["running"],
+};
+
+export const TEAM_TASK_STATUS_TRANSITIONS: Readonly<Record<TeamTaskStatus, readonly TeamTaskStatus[]>> = {
+	queued: ["running", "cancelled", "skipped", "failed"],
+	running: ["completed", "failed", "cancelled", "queued", "waiting"],
+	waiting: ["running", "completed", "failed", "cancelled"],
+	completed: ["queued"],
+	failed: ["queued", "cancelled"],
+	cancelled: ["queued"],
+	skipped: ["queued", "cancelled"],
+};
+
+export const TEAM_EVENT_TYPES = [
+	"run.created",
+	"run.queued",
+	"run.planning",
+	"run.running",
+	"run.blocked",
+	"run.completed",
+	"run.failed",
+	"run.cancelled",
+	"task.started",
+	"task.progress",
+	"task.blocked",
+	"task.green",
+	"task.red",
+	"task.completed",
+	"task.failed",
+	"task.cancelled",
+	"task.skipped",
+	"review.approved",
+	"review.rejected",
+	"policy.action",
+	"policy.escalated",
+	"recovery.attempted",
+	"recovery.escalated",
+	"branch.stale",
+	"mailbox.timeout",
+	"worktree.cleanup",
+	"worktree.dirty",
+	"async.spawned",
+	"async.started",
+	"async.completed",
+	"async.failed",
+	"async.stale",
+	"task.waiting",
+	"task.resumed",
+	"supervisor.contact",
+] as const;
+export type TeamEventType = typeof TEAM_EVENT_TYPES[number];
+
+export const TEAM_WAKEABLE_EVENT_TYPES: ReadonlySet<TeamEventType> = new Set([
+	"run.blocked",
+	"run.completed",
+	"run.failed",
+	"run.cancelled",
+	"task.completed",
+	"task.failed",
+	"task.cancelled",
+	"task.skipped",
+	"async.completed",
+	"async.failed",
+	"async.stale",
+]);
+
+export function isTeamRunStatus(value: unknown): value is TeamRunStatus {
+	return typeof value === "string" && TEAM_RUN_STATUSES.includes(value as TeamRunStatus);
+}
+
+export function isTeamTaskStatus(value: unknown): value is TeamTaskStatus {
+	return typeof value === "string" && TEAM_TASK_STATUSES.includes(value as TeamTaskStatus);
+}
+
+export function isTerminalRunStatus(status: TeamRunStatus): boolean {
+	return TEAM_TERMINAL_RUN_STATUSES.has(status);
+}
+
+export function isTerminalTaskStatus(status: TeamTaskStatus): boolean {
+	return TEAM_TERMINAL_TASK_STATUSES.has(status);
+}
+
+export function canTransitionRunStatus(from: TeamRunStatus, to: TeamRunStatus): boolean {
+	return from === to || (TEAM_RUN_STATUS_TRANSITIONS[from]?.includes(to) ?? false);
+}
+
+export function canTransitionTaskStatus(from: TeamTaskStatus, to: TeamTaskStatus): boolean {
+	return from === to || (TEAM_TASK_STATUS_TRANSITIONS[from]?.includes(to) ?? false);
+}
+
+export function isWakeableTeamEventType(type: TeamEventType): boolean {
+	return TEAM_WAKEABLE_EVENT_TYPES.has(type);
+}

package/src/state/event-log.ts

@@ -28,6 +28,7 @@ export interface TeamEventMetadata {
 	sessionIdentity?: TeamEventSessionIdentity;
 	ownership?: TeamEventOwnership;
 	nudgeId?: string;
+	appended?: boolean;
 	fingerprint?: string;
 	confidence?: "low" | "medium" | "high";
 }
@@ -66,9 +67,7 @@ export function scanSequence(eventsPath: string): number {
 		try {
 			const event = JSON.parse(line) as TeamEvent;
 			max = Math.max(max, event.metadata?.seq ?? 0);
-		} catch {
-			max += 1;
-		}
+		} catch { /* skip corrupt lines without incrementing sequence */ }
 	}
 	return max;
 }
@@ -131,7 +130,7 @@ export function appendEvent(eventsPath: string, event: AppendTeamEvent): TeamEve
 	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;
+			return { ...fullEvent, metadata: { ...(fullEvent.metadata ?? { seq: 0, provenance: "team_runner" }), appended: false } };
 		}
 	} catch (error) {
 		logInternalError("event-log.size-check", error, `eventsPath=${eventsPath}`);

package/src/state/jsonl-writer.ts

@@ -66,7 +66,10 @@ export function createJsonlWriter(filePath: string | undefined, source: Drainabl
 						if (!closed) source.resume();
 					});
 				}
-			} catch {}
+			} catch (writeError) {
+				// Log the error — silently dropping events is dangerous.
+				process.stderr.write(`[pi-crew] jsonl-writer: write failed ${filePath}: ${writeError instanceof Error ? writeError.message : String(writeError)}\n`);
+			}
 		},
 		async close() {
 			if (!stream || closed) return;

package/src/state/locks.ts

@@ -14,7 +14,15 @@ function lockPath(manifest: TeamRunManifest): string {
 }
 
 function sleepSync(ms: number): void {
-	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+	try {
+		Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+	} catch {
+		// Fallback for environments without SharedArrayBuffer / Atomics.wait support.
+		const deadline = Date.now() + ms;
+		while (Date.now() < deadline) {
+			// Busy-wait — only used as last-resort, retry counts are capped.
+		}
+	}
 }
 
 function parseCreatedAtFromLock(raw: string): number | undefined {