pi-crew 0.1.28 → 0.1.30

package/src/extension/team-tool/run.ts

@@ -4,18 +4,55 @@ import { allWorkflows, discoverWorkflows } from "../../workflows/discover-workfl
 import { loadConfig } from "../../config/config.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { writeArtifact } from "../../state/artifact-store.ts";
-import { createRunManifest } from "../../state/state-store.ts";
+import { createRunManifest, loadRunManifestById, updateRunStatus } from "../../state/state-store.ts";
 import { atomicWriteJson } from "../../state/atomic-write.ts";
 import { validateWorkflowForTeam } from "../../workflows/validate-workflow.ts";
 import { executeTeamRun } from "../../runtime/team-runner.ts";
-import { spawnBackgroundTeamRun } from "../../runtime/async-runner.ts";
-import { appendEvent } from "../../state/event-log.ts";
+import { spawnBackgroundTeamRun } from "../../subagents/async-entry.ts";
+import { appendEvent, readEvents } from "../../state/event-log.ts";
 import { resolveCrewRuntime } from "../../runtime/runtime-resolver.ts";
 import { expandParallelResearchWorkflow } from "../../runtime/parallel-research.ts";
+import { checkProcessLiveness, isActiveRunStatus } from "../../runtime/process-status.ts";
+import { hasAsyncStartMarker } from "../../runtime/async-marker.ts";
+import * as fs from "node:fs";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { buildParentContext, result, type TeamContext } from "./context.ts";
 import { effectiveRunConfig } from "./config-patch.ts";
 
+function tailFile(filePath: string, maxBytes = 4096): string | undefined {
+	try {
+		const stat = fs.statSync(filePath);
+		const start = Math.max(0, stat.size - maxBytes);
+		const fd = fs.openSync(filePath, "r");
+		try {
+			const buffer = Buffer.alloc(stat.size - start);
+			fs.readSync(fd, buffer, 0, buffer.length, start);
+			return buffer.toString("utf-8").trim();
+		} finally {
+			fs.closeSync(fd);
+		}
+	} catch {
+		return undefined;
+	}
+}
+
+function scheduleBackgroundEarlyExitGuard(cwd: string, runId: string, pid: number | undefined, logPath: string): void {
+	if (process.env.PI_CREW_ASYNC_EARLY_EXIT_GUARD === "0") return;
+	const timer = setTimeout(() => {
+		const loaded = loadRunManifestById(cwd, runId);
+		if (!loaded || !isActiveRunStatus(loaded.manifest.status)) return;
+		if (hasAsyncStartMarker(loaded.manifest)) return;
+		if (readEvents(loaded.manifest.eventsPath).some((event) => event.type === "async.started" || event.type === "async.completed" || event.type === "async.failed")) return;
+		const liveness = checkProcessLiveness(pid);
+		if (liveness.alive) return;
+		const tail = tailFile(logPath);
+		const message = `Background runner exited within 3s; see background.log${tail ? `\n${tail}` : ""}`;
+		const failed = updateRunStatus(loaded.manifest, "failed", "Background runner exited within 3s; see background.log");
+		appendEvent(failed.eventsPath, { type: "async.failed", runId: failed.runId, message, data: { pid, detail: liveness.detail } });
+	}, 3000);
+	timer.unref?.();
+}
+
 export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
 	const goal = params.goal ?? params.task;
 	if (!goal) return result("Run requires goal or task.", { action: "run", status: "error" }, true);
@@ -75,6 +112,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		const asyncManifest = { ...updatedManifest, async: { pid: spawned.pid, logPath: spawned.logPath, spawnedAt: new Date().toISOString() } };
 		atomicWriteJson(paths.manifestPath, asyncManifest);
 		appendEvent(updatedManifest.eventsPath, { type: "async.spawned", runId: updatedManifest.runId, data: { pid: spawned.pid, logPath: spawned.logPath } });
+		scheduleBackgroundEarlyExitGuard(ctx.cwd, updatedManifest.runId, spawned.pid, spawned.logPath);
 		const text = [
 			`Started async pi-crew run ${updatedManifest.runId}.`,
 			`Team: ${team.name}`,

package/src/extension/team-tool/status.ts

@@ -0,0 +1,73 @@
+import { loadConfig } from "../../config/config.ts";
+import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
+import { appendEvent, readEvents } from "../../state/event-log.ts";
+import { loadRunManifestById, updateRunStatus } from "../../state/state-store.ts";
+import { aggregateUsage, formatUsage } from "../../state/usage.ts";
+import { applyAttentionState, formatActivityAge, resolveCrewControlConfig } from "../../runtime/agent-control.ts";
+import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
+import { checkProcessLiveness, isActiveRunStatus } from "../../runtime/process-status.ts";
+import { formatTaskGraphLines, waitingReason } from "../../runtime/task-display.ts";
+import type { PiTeamsToolResult } from "../tool-result.ts";
+import { result, type TeamContext } from "./context.ts";
+
+export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
+	if (!params.runId) return result("Status requires runId.", { action: "status", status: "error" }, true);
+	const loaded = loadRunManifestById(ctx.cwd, params.runId);
+	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "status", status: "error" }, true);
+	let { manifest, tasks } = loaded;
+	let asyncLivenessLine: string | undefined;
+	if (manifest.async) {
+		const asyncState = manifest.async;
+		const liveness = checkProcessLiveness(asyncState.pid);
+		asyncLivenessLine = `Async: pid=${asyncState.pid ?? "unknown"} alive=${liveness.alive ? "true" : "false"} detail=${liveness.detail} log=${asyncState.logPath} spawnedAt=${asyncState.spawnedAt}`;
+		if (!liveness.alive && isActiveRunStatus(manifest.status)) {
+			manifest = updateRunStatus(manifest, "failed", `Async process stale: ${liveness.detail}`);
+			appendEvent(manifest.eventsPath, { type: "async.stale", runId: manifest.runId, message: liveness.detail, data: { pid: asyncState.pid } });
+		}
+	}
+	const counts = new Map<string, number>();
+	for (const task of tasks) counts.set(task.status, (counts.get(task.status) ?? 0) + 1);
+	const events = readEvents(manifest.eventsPath).slice(-8);
+	const controlConfig = resolveCrewControlConfig(loadConfig(ctx.cwd).config);
+	const crewAgents = readCrewAgents(manifest).map((agent) => applyAttentionState(manifest, agent, controlConfig));
+	const artifactLines = manifest.artifacts.slice(-10).map((artifact) => `- ${artifact.kind}: ${artifact.path}${artifact.sizeBytes !== undefined ? ` (${artifact.sizeBytes} bytes)` : ""}`);
+	const totalUsage = aggregateUsage(tasks);
+	const activeAgents = crewAgents.filter((agent) => agent.status === "running");
+	const completedAgents = crewAgents.filter((agent) => agent.status !== "running");
+	const waitingTasks = tasks.filter((task) => task.status === "queued");
+	const agentLine = (agent: typeof crewAgents[number]): string => `- ${agent.id} [${agent.status}] ${agent.role} -> ${agent.agent} runtime=${agent.runtime}${agent.model ? ` model=${agent.model}` : ""}${agent.usage ? ` usage=${formatUsage(agent.usage)}` : ""}${agent.progress?.activityState === "needs_attention" ? " needs_attention" : ""}${formatActivityAge(agent) ? ` activity=${formatActivityAge(agent)}` : ""}${agent.progress?.currentTool ? ` tool=${agent.progress.currentTool}` : ""}${agent.toolUses ? ` tools=${agent.toolUses}` : ""}${!agent.usage && agent.progress?.tokens ? ` tokens=${agent.progress.tokens}` : ""}${agent.progress?.turns ? ` turns=${agent.progress.turns}` : ""}${agent.jsonEvents !== undefined ? ` jsonEvents=${agent.jsonEvents}` : ""}${agent.statusPath ? ` status=${agent.statusPath}` : ""}${agent.error ? ` error=${agent.error}` : ""}`;
+	const lines = [
+		`Run: ${manifest.runId}`,
+		`Team: ${manifest.team}`,
+		`Workflow: ${manifest.workflow ?? "(none)"}`,
+		`Status: ${manifest.status}`,
+		`Workspace mode: ${manifest.workspaceMode}`,
+		`Goal: ${manifest.goal}`,
+		`Created: ${manifest.createdAt}`,
+		`Updated: ${manifest.updatedAt}`,
+		`State: ${manifest.stateRoot}`,
+		`Artifacts: ${manifest.artifactsRoot}`,
+		...(asyncLivenessLine ? [asyncLivenessLine] : []),
+		"Task graph:",
+		...formatTaskGraphLines(tasks),
+		"Tasks:",
+		...(tasks.length ? tasks.map((task) => `- ${task.id} [${task.status}] ${task.role} -> ${task.agent}${task.taskPacket ? ` scope=${task.taskPacket.scope}` : ""}${task.verification ? ` green=${task.verification.observedGreenLevel}/${task.verification.requiredGreenLevel}` : ""}${task.modelAttempts?.length ? ` attempts=${task.modelAttempts.length}` : ""}${task.modelRouting ? ` modelRouting=${task.modelRouting.requested ? `${task.modelRouting.requested}->` : ""}${task.modelRouting.resolved}${task.modelRouting.usedAttempt ? ` attempt=${task.modelRouting.usedAttempt + 1}` : ""}` : ""}${task.jsonEvents !== undefined ? ` jsonEvents=${task.jsonEvents}` : ""}${task.usage ? ` usage=${JSON.stringify(task.usage)}` : ""}${task.worktree ? ` worktree=${task.worktree.path}` : ""}${task.error ? ` error=${task.error}` : ""}`) : ["- (none)"]),
+		`Task counts: ${[...counts.entries()].map(([status, count]) => `${status}=${count}`).join(", ") || "none"}`,
+		"Active agents:",
+		...(activeAgents.length ? activeAgents.map(agentLine) : ["- (none)"]),
+		"Waiting tasks:",
+		...(waitingTasks.length ? waitingTasks.map((task) => `- ${task.id} [queued] ${task.role} -> ${task.agent} ${waitingReason(task, tasks) ?? "waiting"}`) : ["- (none)"]),
+		"Completed agents:",
+		...(completedAgents.length ? completedAgents.map(agentLine) : ["- (none)"]),
+		"Policy decisions:",
+		...(manifest.policyDecisions?.length ? manifest.policyDecisions.map((item) => `- ${item.action} (${item.reason})${item.taskId ? ` ${item.taskId}` : ""}: ${item.message}`) : ["- (none)"]),
+		`Total usage: ${formatUsage(totalUsage)}`,
+		"",
+		"Recent artifacts:",
+		...(artifactLines.length ? artifactLines : ["- (none)"]),
+		"",
+		"Recent events:",
+		...(events.length ? events.map((event) => `- ${event.time} ${event.type}${event.taskId ? ` ${event.taskId}` : ""}${event.message ? `: ${event.message}` : ""}`) : ["- (none)"]),
+	];
+	return result(lines.join("\n"), { action: "status", status: "ok", runId: manifest.runId, artifactsRoot: manifest.artifactsRoot });
+}

package/src/extension/team-tool.ts

@@ -1,13 +1,16 @@
 import * as fs from "node:fs";
+import * as path from "node:path";
 import { allAgents, discoverAgents } from "../agents/discover-agents.ts";
 import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
 import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
 import { loadConfig, updateAutonomousConfig, updateConfig } from "../config/config.ts";
 import type { TeamToolParamsValue } from "../schema/team-tool-schema.ts";
-import { loadRunManifestById, saveRunTasks, updateRunStatus } from "../state/state-store.ts";
+import { loadRunManifestById, saveRunManifest, saveRunTasks, updateRunStatus } from "../state/state-store.ts";
 import { withRunLock, withRunLockSync } from "../state/locks.ts";
 import { aggregateUsage, formatUsage } from "../state/usage.ts";
 import { appendEvent, readEvents } from "../state/event-log.ts";
+import { writeArtifact } from "../state/artifact-store.ts";
+import { replayPendingMailboxMessages } from "../state/mailbox.ts";
 import { cleanupRunWorktrees } from "../worktree/cleanup.ts";
 import { piTeamsHelp } from "./help.ts";
 import { initializeProject } from "./project-init.ts";
@@ -21,6 +24,7 @@ import { validateWorkflowForTeam } from "../workflows/validate-workflow.ts";
 import { formatValidationReport, validateResources } from "./validate-resources.ts";
 import { formatRecommendation, recommendTeam } from "./team-recommendation.ts";
 import type { PiTeamsToolResult } from "./tool-result.ts";
+import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { executeTeamRun } from "../runtime/team-runner.ts";
 import { checkProcessLiveness, isActiveRunStatus } from "../runtime/process-status.ts";
 import { saveCrewAgents, readCrewAgents, recordFromTask } from "../runtime/crew-agent-records.ts";
@@ -29,17 +33,28 @@ import { applyAttentionState, formatActivityAge, resolveCrewControlConfig } from
 import { writeForegroundInterruptRequest } from "../runtime/foreground-control.ts";
 import { formatTaskGraphLines, waitingReason } from "../runtime/task-display.ts";
 import { directTeamAndWorkflowFromRun } from "../runtime/direct-run.ts";
+import { parsePiJsonOutput } from "../runtime/pi-json-output.ts";
 import { buildParentContext, configRecord, formatScoped, result, type TeamContext } from "./team-tool/context.ts";
 import { autonomousPatchFromConfig, configPatchFromConfig, formatAutonomyStatus } from "./team-tool/config-patch.ts";
 import { handleApi } from "./team-tool/api.ts";
 import { handleRun } from "./team-tool/run.ts";
 import { handleDoctor } from "./team-tool/doctor.ts";
+import { handleStatus } from "./team-tool/status.ts";
+import { handleArtifacts, handleEvents, handleSummary } from "./team-tool/inspect.ts";
+import { handleCleanup, handleExport, handleForget, handleImport, handleImports, handlePrune, handleWorktrees } from "./team-tool/lifecycle-actions.ts";
+import { handleCancel } from "./team-tool/cancel.ts";
+import { handlePlan } from "./team-tool/plan.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 
 export type { TeamToolDetails } from "./team-tool-types.ts";
 export type { TeamContext } from "./team-tool/context.ts";
 export { handleRun } from "./team-tool/run.ts";
 export { handleDoctor } from "./team-tool/doctor.ts";
+export { handleStatus } from "./team-tool/status.ts";
+export { handleArtifacts, handleEvents, handleSummary } from "./team-tool/inspect.ts";
+export { handleCleanup, handleExport, handleForget, handleImport, handleImports, handlePrune, handleWorktrees } from "./team-tool/lifecycle-actions.ts";
+export { handleCancel } from "./team-tool/cancel.ts";
+export { handlePlan } from "./team-tool/plan.ts";
 export { handleApi } from "./team-tool/api.ts";
 
 export function handleList(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
@@ -108,111 +123,43 @@ export function handleGet(params: TeamToolParamsValue, ctx: TeamContext): PiTeam
 	return result("Specify team, workflow, or agent for get.", { action: "get", status: "error" }, true);
 }
 
-export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
-	if (!params.runId) return result("Status requires runId.", { action: "status", status: "error" }, true);
-	const loaded = loadRunManifestById(ctx.cwd, params.runId);
-	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "status", status: "error" }, true);
-	let { manifest, tasks } = loaded;
-	let asyncLivenessLine: string | undefined;
-	if (manifest.async) {
-		const asyncState = manifest.async;
-		const liveness = checkProcessLiveness(asyncState.pid);
-		asyncLivenessLine = `Async: pid=${asyncState.pid ?? "unknown"} alive=${liveness.alive ? "true" : "false"} detail=${liveness.detail} log=${asyncState.logPath} spawnedAt=${asyncState.spawnedAt}`;
-		if (!liveness.alive && isActiveRunStatus(manifest.status)) {
-			manifest = updateRunStatus(manifest, "failed", `Async process stale: ${liveness.detail}`);
-			appendEvent(manifest.eventsPath, { type: "async.stale", runId: manifest.runId, message: liveness.detail, data: { pid: asyncState.pid } });
-		}
-	}
-	const counts = new Map<string, number>();
-	for (const task of tasks) counts.set(task.status, (counts.get(task.status) ?? 0) + 1);
-	const events = readEvents(manifest.eventsPath).slice(-8);
-	const controlConfig = resolveCrewControlConfig(loadConfig(ctx.cwd).config);
-	const crewAgents = readCrewAgents(manifest).map((agent) => applyAttentionState(manifest, agent, controlConfig));
-	const artifactLines = manifest.artifacts.slice(-10).map((artifact) => `- ${artifact.kind}: ${artifact.path}${artifact.sizeBytes !== undefined ? ` (${artifact.sizeBytes} bytes)` : ""}`);
-	const totalUsage = aggregateUsage(tasks);
-	const activeAgents = crewAgents.filter((agent) => agent.status === "running");
-	const completedAgents = crewAgents.filter((agent) => agent.status !== "running");
-	const waitingTasks = tasks.filter((task) => task.status === "queued");
-	const agentLine = (agent: typeof crewAgents[number]): string => `- ${agent.id} [${agent.status}] ${agent.role} -> ${agent.agent} runtime=${agent.runtime}${agent.model ? ` model=${agent.model}` : ""}${agent.usage ? ` usage=${formatUsage(agent.usage)}` : ""}${agent.progress?.activityState === "needs_attention" ? " needs_attention" : ""}${formatActivityAge(agent) ? ` activity=${formatActivityAge(agent)}` : ""}${agent.progress?.currentTool ? ` tool=${agent.progress.currentTool}` : ""}${agent.toolUses ? ` tools=${agent.toolUses}` : ""}${!agent.usage && agent.progress?.tokens ? ` tokens=${agent.progress.tokens}` : ""}${agent.progress?.turns ? ` turns=${agent.progress.turns}` : ""}${agent.jsonEvents !== undefined ? ` jsonEvents=${agent.jsonEvents}` : ""}${agent.statusPath ? ` status=${agent.statusPath}` : ""}${agent.error ? ` error=${agent.error}` : ""}`;
-	const lines = [
-		`Run: ${manifest.runId}`,
-		`Team: ${manifest.team}`,
-		`Workflow: ${manifest.workflow ?? "(none)"}`,
-		`Status: ${manifest.status}`,
-		`Workspace mode: ${manifest.workspaceMode}`,
-		`Goal: ${manifest.goal}`,
-		`Created: ${manifest.createdAt}`,
-		`Updated: ${manifest.updatedAt}`,
-		`State: ${manifest.stateRoot}`,
-		`Artifacts: ${manifest.artifactsRoot}`,
-		...(asyncLivenessLine ? [asyncLivenessLine] : []),
-		"Task graph:",
-		...formatTaskGraphLines(tasks),
-		"Tasks:",
-		...(tasks.length ? tasks.map((task) => `- ${task.id} [${task.status}] ${task.role} -> ${task.agent}${task.taskPacket ? ` scope=${task.taskPacket.scope}` : ""}${task.verification ? ` green=${task.verification.observedGreenLevel}/${task.verification.requiredGreenLevel}` : ""}${task.modelAttempts?.length ? ` attempts=${task.modelAttempts.length}` : ""}${task.jsonEvents !== undefined ? ` jsonEvents=${task.jsonEvents}` : ""}${task.usage ? ` usage=${JSON.stringify(task.usage)}` : ""}${task.worktree ? ` worktree=${task.worktree.path}` : ""}${task.error ? ` error=${task.error}` : ""}`) : ["- (none)"]),
-		`Task counts: ${[...counts.entries()].map(([status, count]) => `${status}=${count}`).join(", ") || "none"}`,
-		"Active agents:",
-		...(activeAgents.length ? activeAgents.map(agentLine) : ["- (none)"]),
-		"Waiting tasks:",
-		...(waitingTasks.length ? waitingTasks.map((task) => `- ${task.id} [queued] ${task.role} -> ${task.agent} ${waitingReason(task, tasks) ?? "waiting"}`) : ["- (none)"]),
-		"Completed agents:",
-		...(completedAgents.length ? completedAgents.map(agentLine) : ["- (none)"]),
-		"Policy decisions:",
-		...(manifest.policyDecisions?.length ? manifest.policyDecisions.map((item) => `- ${item.action} (${item.reason})${item.taskId ? ` ${item.taskId}` : ""}: ${item.message}`) : ["- (none)"]),
-		`Total usage: ${formatUsage(totalUsage)}`,
-		"",
-		"Recent artifacts:",
-		...(artifactLines.length ? artifactLines : ["- (none)"]),
-		"",
-		"Recent events:",
-		...(events.length ? events.map((event) => `- ${event.time} ${event.type}${event.taskId ? ` ${event.taskId}` : ""}${event.message ? `: ${event.message}` : ""}`) : ["- (none)"]),
-	];
-	return result(lines.join("\n"), { action: "status", status: "ok", runId: manifest.runId, artifactsRoot: manifest.artifactsRoot });
-}
-
-export function handlePlan(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
-	const teamName = params.team ?? "default";
-	const team = allTeams(discoverTeams(ctx.cwd)).find((item) => item.name === teamName);
-	if (!team) return result(`Team '${teamName}' not found.`, { action: "plan", status: "error" }, true);
-	const workflowName = params.workflow ?? team.defaultWorkflow ?? "default";
-	const workflow = allWorkflows(discoverWorkflows(ctx.cwd)).find((item) => item.name === workflowName);
-	if (!workflow) return result(`Workflow '${workflowName}' not found.`, { action: "plan", status: "error" }, true);
-	const errors = validateWorkflowForTeam(workflow, team);
-	if (errors.length > 0) return result([`Workflow '${workflow.name}' is not valid for team '${team.name}':`, ...errors.map((error) => `- ${error}`)].join("\n"), { action: "plan", status: "error" }, true);
-	const lines = [
-		`Team plan: ${team.name}`,
-		`Workflow: ${workflow.name}`,
-		`Goal: ${params.goal ?? params.task ?? "(not provided)"}`,
-		"",
-		"Steps:",
-		...workflow.steps.map((step, index) => `${index + 1}. ${step.id} [${step.role}]${step.dependsOn?.length ? ` after ${step.dependsOn.join(", ")}` : ""}`),
-	];
-	return result(lines.join("\n"), { action: "plan", status: "ok" });
+function artifactKey(artifact: ArtifactDescriptor): string {
+	return `${artifact.kind}:${artifact.path}`;
 }
 
-export function handleCancel(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
-	if (!params.runId) return result("Cancel requires runId.", { action: "cancel", status: "error" }, true);
-	const loaded = loadRunManifestById(ctx.cwd, params.runId);
-	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "cancel", status: "error" }, true);
-	return withRunLockSync(loaded.manifest, () => {
-		if (loaded.manifest.status === "completed" && !params.force) {
-			return result(`Run ${loaded.manifest.runId} is already completed; nothing to cancel. Use force: true to mark it cancelled anyway.`, { action: "cancel", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
-		}
-		const tasks = loaded.tasks.map((task) => task.status === "queued" || task.status === "running" ? { ...task, status: "cancelled" as const, finishedAt: new Date().toISOString(), error: "Run cancelled by user request." } : task);
-		saveRunTasks(loaded.manifest, tasks);
-		try {
-			saveCrewAgents(loaded.manifest, tasks.map((task) => recordFromTask(loaded.manifest, task, "child-process")));
-		} catch (error) {
-			logInternalError("team-tool.handleCancel.crewAgents", error, `runId=${loaded.manifest.runId}`);
+function recoverCheckpointedTasks(manifest: TeamRunManifest, tasks: TeamTaskState[]): { manifest: TeamRunManifest; tasks: TeamTaskState[]; recovered: string[] } {
+	const recovered: string[] = [];
+	let nextManifest = manifest;
+	let nextTasks = tasks.map((task) => {
+		if (task.status !== "running" || !task.checkpoint) return task;
+		if (task.checkpoint.phase === "artifact-written" && task.resultArtifact) {
+			recovered.push(task.id);
+			return { ...task, status: "completed" as const, finishedAt: task.finishedAt ?? task.checkpoint.updatedAt, error: undefined, claim: undefined };
 		}
-		try {
-			writeForegroundInterruptRequest(loaded.manifest, "Run cancelled by user request.");
-		} catch (error) {
-			logInternalError("team-tool.handleCancel.interruptRequest", error, `runId=${loaded.manifest.runId}`);
+		if (task.checkpoint.phase === "child-stdout-final") {
+			const transcriptPath = path.join(manifest.artifactsRoot, "transcripts", `${task.id}.jsonl`);
+			if (!fs.existsSync(transcriptPath)) return task;
+			const transcript = fs.readFileSync(transcriptPath, "utf-8");
+			const parsed = parsePiJsonOutput(transcript);
+			if (!parsed.finalText && !parsed.usage) return task;
+			const resultArtifact = writeArtifact(manifest.artifactsRoot, { kind: "result", relativePath: `results/${task.id}.txt`, content: parsed.finalText ?? "(recovered from completed child transcript)", producer: task.id });
+			const transcriptArtifact = writeArtifact(manifest.artifactsRoot, { kind: "log", relativePath: `transcripts/${task.id}.jsonl`, content: transcript, producer: task.id });
+			recovered.push(task.id);
+			return { ...task, status: "completed" as const, finishedAt: task.finishedAt ?? task.checkpoint.updatedAt, error: undefined, claim: undefined, resultArtifact, transcriptArtifact, usage: parsed.usage, jsonEvents: parsed.jsonEvents };
 		}
-		const updated = updateRunStatus(loaded.manifest, "cancelled", "Run cancelled by user request. Already-finished worker processes are not retroactively changed.");
-		return result(`Cancelled run ${updated.runId}.`, { action: "cancel", status: "ok", runId: updated.runId, artifactsRoot: updated.artifactsRoot });
+		return task;
 	});
+	if (recovered.length) {
+		const artifacts = new Map(nextManifest.artifacts.map((artifact) => [artifactKey(artifact), artifact]));
+		for (const task of nextTasks) {
+			if (!recovered.includes(task.id)) continue;
+			for (const artifact of [task.promptArtifact, task.resultArtifact, task.logArtifact, task.transcriptArtifact].filter(Boolean) as ArtifactDescriptor[]) artifacts.set(artifactKey(artifact), artifact);
+		}
+		nextManifest = { ...nextManifest, artifacts: [...artifacts.values()], updatedAt: new Date().toISOString() };
+		saveRunManifest(nextManifest);
+		saveRunTasks(nextManifest, nextTasks);
+	}
+	return { manifest: nextManifest, tasks: nextTasks, recovered };
 }
 
 export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
@@ -227,136 +174,22 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 	const workflow = direct?.workflow ?? allWorkflows(discoverWorkflows(ctx.cwd)).find((candidate) => candidate.name === loaded.manifest.workflow);
 	if (!workflow) return result(`Workflow '${loaded.manifest.workflow}' not found.`, { action: "resume", status: "error" }, true);
 	return await withRunLock(loaded.manifest, async () => {
-		const resetTasks = loaded.tasks.map((task) => task.status === "failed" || task.status === "cancelled" || task.status === "skipped" || task.status === "running" ? { ...task, status: "queued" as const, error: undefined, startedAt: undefined, finishedAt: undefined, claim: undefined } : task);
-		saveRunTasks(loaded.manifest, resetTasks);
-		appendEvent(loaded.manifest.eventsPath, { type: "run.resume_requested", runId: loaded.manifest.runId });
+		const recovered = recoverCheckpointedTasks(loaded.manifest, loaded.tasks);
+		const resumeManifest = recovered.manifest;
+		const resetTasks = recovered.tasks.map((task) => task.status === "failed" || task.status === "cancelled" || task.status === "skipped" || task.status === "running" ? { ...task, status: "queued" as const, error: undefined, startedAt: undefined, finishedAt: undefined, claim: undefined } : task);
+		saveRunTasks(resumeManifest, resetTasks);
+		const replay = replayPendingMailboxMessages(resumeManifest);
+		appendEvent(resumeManifest.eventsPath, { type: "run.resume_requested", runId: resumeManifest.runId, data: { replayedMailboxMessages: replay.messages.length, recoveredCheckpointTasks: recovered.recovered } });
+		if (recovered.recovered.length) appendEvent(resumeManifest.eventsPath, { type: "task.checkpoint_recovered", runId: resumeManifest.runId, message: `Recovered ${recovered.recovered.length} task(s) from artifact-written checkpoints.`, data: { taskIds: recovered.recovered } });
+		if (replay.messages.length) appendEvent(resumeManifest.eventsPath, { type: "mailbox.replayed", runId: resumeManifest.runId, message: `Replayed ${replay.messages.length} pending inbox message(s).`, data: { messageIds: replay.messages.map((message) => message.id), taskIds: replay.messages.map((message) => message.taskId).filter(Boolean) } });
 		const loadedConfig = loadConfig(ctx.cwd);
 		const runtime = await resolveCrewRuntime(loadedConfig.config);
 		const executeWorkers = runtime.kind !== "scaffold";
-		const executed = await executeTeamRun({ manifest: loaded.manifest, tasks: resetTasks, team, workflow, agents, executeWorkers, limits: loadedConfig.config.limits, runtime, runtimeConfig: loadedConfig.config.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, signal: ctx.signal });
+		const executed = await executeTeamRun({ manifest: resumeManifest, tasks: resetTasks, team, workflow, agents, executeWorkers, limits: loadedConfig.config.limits, runtime, runtimeConfig: loadedConfig.config.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, signal: ctx.signal });
 		return result([`Resumed run ${executed.manifest.runId}.`, `Status: ${executed.manifest.status}`, `Tasks: ${executed.tasks.length}`, `Artifacts: ${executed.manifest.artifactsRoot}`].join("\n"), { action: "resume", status: executed.manifest.status === "failed" ? "error" : "ok", runId: executed.manifest.runId, artifactsRoot: executed.manifest.artifactsRoot }, executed.manifest.status === "failed");
 	});
 }
 
-export function handleEvents(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
-	if (!params.runId) return result("Events requires runId.", { action: "events", status: "error" }, true);
-	const loaded = loadRunManifestById(ctx.cwd, params.runId);
-	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "events", status: "error" }, true);
-	const events = readEvents(loaded.manifest.eventsPath);
-	const lines = [`Events for ${loaded.manifest.runId}:`, ...(events.length ? events.map((event) => `${event.time} ${event.type}${event.taskId ? ` ${event.taskId}` : ""}${event.message ? `: ${event.message}` : ""}${event.data ? ` ${JSON.stringify(event.data)}` : ""}`) : ["(none)"])];
-	return result(lines.join("\n"), { action: "events", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
-}
-
-export function handleArtifacts(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
-	if (!params.runId) return result("Artifacts requires runId.", { action: "artifacts", status: "error" }, true);
-	const loaded = loadRunManifestById(ctx.cwd, params.runId);
-	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "artifacts", status: "error" }, true);
-	const lines = [`Artifacts for ${loaded.manifest.runId}:`, ...(loaded.manifest.artifacts.length ? loaded.manifest.artifacts.map((artifact) => `- ${artifact.kind}: ${artifact.path}${artifact.sizeBytes !== undefined ? ` (${artifact.sizeBytes} bytes)` : ""}${artifact.contentHash ? ` sha256=${artifact.contentHash.slice(0, 12)}` : ""}`) : ["- (none)"])];
-	return result(lines.join("\n"), { action: "artifacts", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
-}
-
-export function handleSummary(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
-	if (!params.runId) return result("Summary requires runId.", { action: "summary", status: "error" }, true);
-	const loaded = loadRunManifestById(ctx.cwd, params.runId);
-	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "summary", status: "error" }, true);
-	const usage = aggregateUsage(loaded.tasks);
-	const lines = [
-		`Summary for ${loaded.manifest.runId}`,
-		`Status: ${loaded.manifest.status}`,
-		`Team: ${loaded.manifest.team}`,
-		`Workflow: ${loaded.manifest.workflow ?? "(none)"}`,
-		`Goal: ${loaded.manifest.goal}`,
-		`Usage: ${formatUsage(usage)}`,
-		"Tasks:",
-		...loaded.tasks.map((task) => `- ${task.id}: ${task.status} (${task.role} -> ${task.agent})${task.error ? ` - ${task.error}` : ""}`),
-	];
-	return result(lines.join("\n"), { action: "summary", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
-}
-
-export function handleWorktrees(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
-	if (!params.runId) return result("Worktrees requires runId.", { action: "worktrees", status: "error" }, true);
-	const loaded = loadRunManifestById(ctx.cwd, params.runId);
-	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "worktrees", status: "error" }, true);
-	const withWorktrees = loaded.tasks.filter((task) => task.worktree);
-	const lines = [
-		`Worktrees for ${loaded.manifest.runId}:`,
-		...(withWorktrees.length ? withWorktrees.map((task) => `- ${task.id}: ${task.worktree!.path} branch=${task.worktree!.branch} reused=${task.worktree!.reused ? "true" : "false"}`) : ["- (none)"]),
-	];
-	return result(lines.join("\n"), { action: "worktrees", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
-}
-
-export function handleImports(_params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
-	const imports = listImportedRuns(ctx.cwd);
-	const lines = [
-		"Imported pi-crew runs:",
-		...(imports.length ? imports.map((entry) => `- ${entry.runId} (${entry.scope})${entry.status ? ` [${entry.status}]` : ""} ${entry.team ?? "unknown"}/${entry.workflow ?? "none"}: ${entry.goal ?? ""}\n  Bundle: ${entry.bundlePath}\n  Summary: ${entry.summaryPath}`) : ["- (none)"]),
-	];
-	return result(lines.join("\n"), { action: "imports", status: "ok" });
-}
-
-export function handleImport(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
-	const cfg = configRecord(params.config);
-	const bundlePath = typeof cfg.path === "string" ? cfg.path : typeof cfg.bundlePath === "string" ? cfg.bundlePath : undefined;
-	if (!bundlePath) return result("Import requires config.path pointing at run-export.json.", { action: "import", status: "error" }, true);
-	const scope = cfg.scope === "user" ? "user" : "project";
-	try {
-		const imported = importRunBundle(ctx.cwd, bundlePath, scope);
-		return result([`Imported run bundle ${imported.runId}.`, `Bundle: ${imported.bundlePath}`, `Summary: ${imported.summaryPath}`].join("\n"), { action: "import", status: "ok" });
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		return result(`Import failed: ${message}`, { action: "import", status: "error" }, true);
-	}
-}
-
-export function handleExport(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
-	if (!params.runId) return result("Export requires runId.", { action: "export", status: "error" }, true);
-	const loaded = loadRunManifestById(ctx.cwd, params.runId);
-	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "export", status: "error" }, true);
-	const exported = exportRunBundle(loaded.manifest, loaded.tasks);
-	appendEvent(loaded.manifest.eventsPath, { type: "run.exported", runId: loaded.manifest.runId, data: exported });
-	return result([`Exported run ${loaded.manifest.runId}.`, `JSON: ${exported.jsonPath}`, `Markdown: ${exported.markdownPath}`].join("\n"), { action: "export", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
-}
-
-export function handlePrune(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
-	const keep = params.keep ?? 20;
-	if (!params.confirm) return result("prune requires confirm: true.", { action: "prune", status: "error" }, true);
-	if (keep < 0 || !Number.isInteger(keep)) return result("keep must be an integer >= 0.", { action: "prune", status: "error" }, true);
-	const pruned = pruneFinishedRuns(ctx.cwd, keep);
-	return result([`Pruned finished pi-crew runs.`, `Kept: ${pruned.kept.length}`, `Removed: ${pruned.removed.length}`, ...(pruned.removed.length ? ["Removed runs:", ...pruned.removed.map((runId) => `- ${runId}`)] : [])].join("\n"), { action: "prune", status: "ok" });
-}
-
-export function handleForget(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
-	if (!params.runId) return result("Forget requires runId.", { action: "forget", status: "error" }, true);
-	if (!params.confirm) return result("forget requires confirm: true.", { action: "forget", status: "error" }, true);
-	const loaded = loadRunManifestById(ctx.cwd, params.runId);
-	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "forget", status: "error" }, true);
-	const cleanup = cleanupRunWorktrees(loaded.manifest, { force: params.force });
-	if (cleanup.preserved.length > 0 && !params.force) {
-		return result([`Run '${params.runId}' has preserved worktrees. Use force: true to forget anyway.`, ...cleanup.preserved.map((item) => `- ${item.path}: ${item.reason}`)].join("\n"), { action: "forget", status: "error", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot }, true);
-	}
-	fs.rmSync(loaded.manifest.stateRoot, { recursive: true, force: true });
-	fs.rmSync(loaded.manifest.artifactsRoot, { recursive: true, force: true });
-	return result([`Forgot run ${loaded.manifest.runId}.`, `Removed state: ${loaded.manifest.stateRoot}`, `Removed artifacts: ${loaded.manifest.artifactsRoot}`, ...(cleanup.removed.length ? ["Removed worktrees:", ...cleanup.removed.map((item) => `- ${item}`)] : [])].join("\n"), { action: "forget", status: "ok", runId: loaded.manifest.runId });
-}
-
-export function handleCleanup(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
-	if (!params.runId) return result("Cleanup requires runId.", { action: "cleanup", status: "error" }, true);
-	const loaded = loadRunManifestById(ctx.cwd, params.runId);
-	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "cleanup", status: "error" }, true);
-	const cleanup = cleanupRunWorktrees(loaded.manifest, { force: params.force });
-	appendEvent(loaded.manifest.eventsPath, { type: "worktree.cleanup", runId: loaded.manifest.runId, data: { removed: cleanup.removed, preserved: cleanup.preserved, artifacts: cleanup.artifactPaths } });
-	const lines = [
-		`Worktree cleanup for ${loaded.manifest.runId}:`,
-		"Removed:",
-		...(cleanup.removed.length ? cleanup.removed.map((item) => `- ${item}`) : ["- (none)"]),
-		"Preserved:",
-		...(cleanup.preserved.length ? cleanup.preserved.map((item) => `- ${item.path}: ${item.reason}`) : ["- (none)"]),
-		"Artifacts:",
-		...(cleanup.artifactPaths.length ? cleanup.artifactPaths.map((item) => `- ${item}`) : ["- (none)"]),
-	];
-	return result(lines.join("\n"), { action: "cleanup", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
-}
-
 export async function handleTeamTool(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
 	const action = params.action ?? "list";
 	switch (action) {

package/src/runtime/async-marker.ts

@@ -0,0 +1,26 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { atomicWriteJson } from "../state/atomic-write.ts";
+import type { TeamRunManifest } from "../state/types.ts";
+
+export interface AsyncStartMarker {
+	pid: number;
+	startedAt: string;
+}
+
+export function asyncStartMarkerPath(manifest: Pick<TeamRunManifest, "stateRoot">): string {
+	return path.join(manifest.stateRoot, "async.pid");
+}
+
+export function writeAsyncStartMarker(manifest: Pick<TeamRunManifest, "stateRoot">, marker: AsyncStartMarker): void {
+	atomicWriteJson(asyncStartMarkerPath(manifest), marker);
+}
+
+export function hasAsyncStartMarker(manifest: Pick<TeamRunManifest, "stateRoot">): boolean {
+	try {
+		const raw = JSON.parse(fs.readFileSync(asyncStartMarkerPath(manifest), "utf-8")) as Partial<AsyncStartMarker>;
+		return typeof raw.pid === "number" && Number.isInteger(raw.pid) && raw.pid > 0 && typeof raw.startedAt === "string" && raw.startedAt.length > 0;
+	} catch {
+		return false;
+	}
+}

package/src/runtime/async-runner.ts

@@ -1,12 +1,38 @@
 import { spawn, type SpawnOptions } from "node:child_process";
+import { createRequire } from "node:module";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { appendEvent } from "../state/event-log.ts";
 import type { TeamRunManifest } from "../state/types.ts";
 
-export function getBackgroundRunnerCommand(runnerPath: string, cwd: string, runId: string): { args: string[]; loader: "jiti" } {
-	const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
-	const jitiRegisterPath = path.join(packageRoot, "node_modules", "jiti", "lib", "jiti-register.mjs");
+export type FileExists = (filePath: string) => boolean;
+
+const requireFromHere = createRequire(import.meta.url);
+
+function packageRootFromRuntime(): string {
+	return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+}
+
+function jitiRegisterPathFromPackageJson(packageJsonPath: string): string {
+	return path.join(path.dirname(packageJsonPath), "lib", "jiti-register.mjs");
+}
+
+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"),
+	];
+	try {
+		candidates.push(jitiRegisterPathFromPackageJson(requireFromHere.resolve("jiti/package.json")));
+	} catch {
+		// Fall through to explicit candidate checks.
+	}
+	return [...new Set(candidates)].find((candidate) => exists(candidate));
+}
+
+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.");
 	return {
 		args: ["--import", pathToFileURL(jitiRegisterPath).href, runnerPath, "--cwd", cwd, "--run-id", runId],
 		loader: "jiti",
@@ -33,10 +59,19 @@ export function spawnBackgroundTeamRun(manifest: TeamRunManifest): SpawnBackgrou
 	const logPath = path.join(manifest.stateRoot, "background.log");
 	fs.mkdirSync(manifest.stateRoot, { recursive: true });
 	const logFd = fs.openSync(logPath, "a");
-	const command = getBackgroundRunnerCommand(runnerPath, manifest.cwd, manifest.runId);
-	fs.appendFileSync(logPath, `[pi-crew] background loader=${command.loader}\n`, "utf-8");
-	const child = spawn(process.execPath, command.args, buildBackgroundSpawnOptions(manifest, logFd));
-	child.unref();
-	fs.closeSync(logFd);
-	return { pid: child.pid, logPath };
+	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.";
+			appendEvent(manifest.eventsPath, { type: "async.failed", runId: manifest.runId, message });
+			throw new Error(message);
+		}
+		const command = getBackgroundRunnerCommand(runnerPath, manifest.cwd, manifest.runId, jitiRegisterPath);
+		fs.appendFileSync(logPath, `[pi-crew] background loader=${command.loader}\n`, "utf-8");
+		const child = spawn(process.execPath, command.args, buildBackgroundSpawnOptions(manifest, logFd));
+		child.unref();
+		return { pid: child.pid, logPath };
+	} finally {
+		fs.closeSync(logFd);
+	}
 }

package/src/runtime/background-runner.ts

@@ -8,6 +8,7 @@ import { executeTeamRun } from "./team-runner.ts";
 import { resolveCrewRuntime } from "./runtime-resolver.ts";
 import { directTeamAndWorkflowFromRun } from "./direct-run.ts";
 import { expandParallelResearchWorkflow } from "./parallel-research.ts";
+import { writeAsyncStartMarker } from "./async-marker.ts";
 
 function argValue(name: string): string | undefined {
 	const index = process.argv.indexOf(name);
@@ -24,6 +25,7 @@ async function main(): Promise<void> {
 	if (!loaded) throw new Error(`Run '${runId}' not found.`);
 	let { manifest, tasks } = loaded;
 	appendEvent(manifest.eventsPath, { type: "async.started", runId: manifest.runId, data: { pid: process.pid } });
+	writeAsyncStartMarker(manifest, { pid: process.pid, startedAt: new Date().toISOString() });
 
 	try {
 		const agents = allAgents(discoverAgents(cwd));

package/src/runtime/child-pi.ts

@@ -91,6 +91,7 @@ export interface ChildPiRunInput {
 	transcriptPath?: string;
 	onStdoutLine?: (line: string) => void;
 	onJsonEvent?: (event: unknown) => void;
+	onSpawn?: (pid: number) => void;
 	maxDepth?: number;
 	finalDrainMs?: number;
 	hardKillMs?: number;
@@ -286,7 +287,10 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 	try {
 		return await new Promise<ChildPiRunResult>((resolve) => {
 			const child = spawn(spawnSpec.command, spawnSpec.args, buildChildPiSpawnOptions(input.cwd, { ...process.env, ...built.env }));
-			if (child.pid) activeChildProcesses.set(child.pid, child);
+			if (child.pid) {
+				activeChildProcesses.set(child.pid, child);
+				input.onSpawn?.(child.pid);
+			}
 			let stdout = "";
 			let stderr = "";
 			let settled = false;