pi-crew 0.9.57 → 0.9.59

package/src/extension/session-summary.ts

@@ -1,11 +1,16 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
 import { isDisplayActiveRun } from "../runtime/process-status.ts";
+import { extractSessionId } from "../utils/session-utils.ts";
 import { listRuns } from "./run-index.ts";
 
 export function notifyActiveRuns(ctx: ExtensionContext): void {
+	const sid = extractSessionId(ctx);
 	const active = listRuns(ctx.cwd)
 		.filter((run) => {
+			// Vector #11: never surface another session's runs in the active-runs
+			// toast — session B must not advertise session A's in-flight runs.
+			if (sid && run.ownerSessionId && run.ownerSessionId !== sid) return false;
 			if (run.status !== "queued" && run.status !== "planning" && run.status !== "running") return false;
 			// Use the same display filter as the widget/powerbar — runs without
 			// real agent evidence (e.g. integration test fixtures) must not appear.

package/src/extension/team-tool/destructive-gate.ts

@@ -11,10 +11,11 @@
  *
  * Rules (in order):
  *  1. Non-team / non-destructive actions → allowed (caller pre-filters, but safe).
- *  2. `cleanup` with `dryRun=true` → ALWAYS allowed (a preview writes nothing,
- *     so gating it would block users from previewing what cleanup would do —
- *     this was a UX bug: team action=cleanup dryRun=true returned "requires
- *     confirm=true" even though it changed no files).
+ *  2. `cleanup`/`prune` with `dryRun=true` → ALWAYS allowed (a preview writes
+ *     nothing, so gating it would block users from previewing what the action
+ *     would do — this was a UX bug: team action=cleanup dryRun=true returned
+ *     "requires confirm=true" even though it changed no files; prune gained a
+ *     true dryRun preview in the prune-honor-dryRun fix).
  *  3. `confirm=true` on the input → allowed (explicit user intent).
  *  4. `delete` with `force=true` → allowed (force bypasses reference checks).
  *  5. Otherwise → blocked with a reason telling the user what to pass.
@@ -43,8 +44,13 @@ export interface TeamToolInputLike {
  */
 export function shouldBlockDestructiveTeamAction(action: string | undefined, input: TeamToolInputLike): string | undefined {
 	if (!action || !DESTRUCTIVE_TEAM_ACTIONS.has(action)) return undefined;
-	// dryRun cleanup is a PREVIEW (no writes) — never needs confirm.
-	if (action === "cleanup" && input.dryRun === true) return undefined;
+	// dryRun is a PREVIEW (no writes) — never needs confirm. Only allow the
+	// bypass for actions whose handlers actually honor dryRun as non-destructive:
+	//   - cleanup (handleProjectCleanup/handleUserCleanup branch on dryRun)
+	//   - prune   (pruneFinishedRuns skips deletion/worktree-cleanup/audit when
+	//              dryRun; handlePrune bypasses confirm)
+	// forget/delete have no dryRun path (they always mutate), so they stay gated.
+	if ((action === "cleanup" || action === "prune") && input.dryRun === true) return undefined;
 	if (input.confirm === true) return undefined;
 	const forceBypassesReferenceChecks = action === "delete" && input.force === true;
 	if (forceBypassesReferenceChecks) return undefined;

package/src/extension/team-tool/health-monitor.ts

@@ -7,6 +7,7 @@ import * as path from "node:path";
 import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
 import { hasStaleAsyncProcess, isActiveRunStatus, isLikelyOrphanedActiveRun } from "../../runtime/process-status.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
+import { loadTasksWithRecovery } from "../../state/stores/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
 import { listRuns } from "../run-index.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
@@ -63,12 +64,13 @@ export const STUCK_TASK_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
  * Read tasks.json for a given run's stateRoot. Returns empty array on error.
  */
 function readRunTasks(stateRoot: string): TeamTaskState[] {
+	// NEW-R2: use corruption recovery instead of bare JSON.parse. A corrupt
+	// tasks.json previously returned [] → stuck/crashed workers invisible to the
+	// health monitor. Now: corrupt → quarantine + reconstruct from events.jsonl.
 	const tasksPath = path.join(stateRoot, "tasks.json");
-	try {
-		return JSON.parse(fs.readFileSync(tasksPath, "utf-8")) as TeamTaskState[];
-	} catch {
-		return [];
-	}
+	const eventsPath = path.join(stateRoot, "events.jsonl");
+	const runId = path.basename(stateRoot);
+	return loadTasksWithRecovery(tasksPath, eventsPath, runId);
 }
 
 /**

package/src/extension/team-tool/intent-policy.ts

@@ -31,6 +31,15 @@ export function enforceDestructiveIntent(
 	config: PiTeamsConfig | undefined,
 ): PiTeamsToolResult | undefined {
 	if (!shouldRequireIntent(config)) return undefined;
+	// DI-4: The cleanup bypass for non-forced cleanup is INTENTIONAL — do NOT
+	// "fix" this into a regression. Non-forced cleanup (`cleanup` without
+	// `force: true`) only removes STALE artifacts and preserves dirty worktrees
+	// (see cleanupRunWorktrees: dirty worktrees are snapshotted + preserved
+	// unless force=true, and project-level cleanup only removes the AGENTS.md
+	// guidance block without touching `.crew/`). The destructive path (forced
+	// cleanup) still requires intent. Requiring intent for the non-forced,
+	// stale-only path would break routine maintenance flows (e.g. periodic
+	// stale-artifact reaping) that must not need a per-call intent.
 	if (action === "cleanup" && params.force !== true) return undefined;
 	if (intentFromConfig(params.config)) return undefined;
 	const label = DESTRUCTIVE_ACTION_LABELS[action];

package/src/extension/team-tool/lifecycle-actions.ts

@@ -10,6 +10,7 @@ import { loadRunManifestById } from "../../state/stores/state-store.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
 import { projectCrewRoot, userCrewRoot, userPiRoot } from "../../utils/paths.ts";
 import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
+import { sleep } from "../../utils/sleep.ts";
 import { cleanupRunWorktrees } from "../../worktree/cleanup.ts";
 import { listImportedRuns } from "../import-index.ts";
 import { exportRunBundle } from "../run-export.ts";
@@ -146,7 +147,12 @@ export async function handleExport(params: TeamToolParamsValue, ctx: TeamContext
 export async function handlePrune(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
 	const intentError = enforceDestructiveIntent("prune", params, ctx.config);
 	if (intentError) return intentError;
-	if (!params.confirm)
+	// dryRun:true is a non-destructive preview (no deletion) and is always allowed
+	// without confirm — mirrors handleCleanup. Without this, a caller requesting a
+	// dry-run preview with confirm:false was forced to set confirm:true, and the
+	// handler then ignored dryRun entirely and DELETED runs (data-safety bug).
+	const dryRun = params.dryRun === true;
+	if (!params.confirm && !dryRun)
 		return result(
 			paramRequired("prune", "confirm: true", "{ action: 'prune', confirm: true }"),
 			{ action: "prune", status: "error" },
@@ -158,6 +164,7 @@ export async function handlePrune(params: TeamToolParamsValue, ctx: TeamContext)
 	const pruned = pruneFinishedRuns(ctx.cwd, keep, {
 		intent,
 		signal: ctx.signal,
+		dryRun,
 	});
 	// Fire hook once with all removed run IDs for batch visibility
 	if (pruned.removed.length > 0) {
@@ -176,11 +183,13 @@ export async function handlePrune(params: TeamToolParamsValue, ctx: TeamContext)
 	}
 	return result(
 		[
-			`Pruned finished pi-crew runs.`,
+			`${dryRun ? "Preview: " : ""}Pruned finished pi-crew runs.`,
 			`Kept: ${pruned.kept.length}`,
-			`Removed: ${pruned.removed.length}`,
+			`${dryRun ? "Would remove" : "Removed"}: ${pruned.removed.length}`,
 			...(pruned.auditPath ? [`Audit: ${pruned.auditPath}`] : []),
-			...(pruned.removed.length ? ["Removed runs:", ...pruned.removed.map((runId) => `- ${runId}`)] : []),
+			...(pruned.removed.length
+				? [`${dryRun ? "Would remove" : "Removed"} runs:`, ...pruned.removed.map((runId) => `- ${runId}`)]
+				: []),
 		].join("\n"),
 		{ action: "prune", status: "ok", intent },
 	);
@@ -282,6 +291,20 @@ export async function handleForget(params: TeamToolParamsValue, ctx: TeamContext
 	const resolvedArtifactsRoot = resolveRealContainedPath(crewRoot, loaded.manifest.artifactsRoot);
 	fs.rmSync(resolvedStateRoot, { recursive: true, force: true });
 	fs.rmSync(resolvedArtifactsRoot, { recursive: true, force: true });
+	// FORGET-RESURRECT (observed 2026-08-04): the SIGTERM above is fire-and-forget
+	// (killProcessPid returns void; no await on process-group exit). A still-alive
+	// background runner/worker can land one final heartbeat write (15s interval)
+	// AFTER the first rmSync — atomicWriteFile mkdirSync(recursive) RE-CREATES the
+	// state dir, resurrecting heartbeat.json in a dir we just forgot. Drain briefly
+	// (grace period for in-flight writes) then re-remove any resurrected residue.
+	// A 250ms window catches the common in-flight write race; a still-running
+	// (un-killable) process could resurrect later, but that is a separate leak
+	// (zombie process) that the stale-reconciler re-prunes.
+	if (fs.existsSync(resolvedStateRoot) || fs.existsSync(resolvedArtifactsRoot)) {
+		await sleep(250);
+		fs.rmSync(resolvedStateRoot, { recursive: true, force: true });
+		fs.rmSync(resolvedArtifactsRoot, { recursive: true, force: true });
+	}
 	return result(
 		[
 			`Forgot run ${loaded.manifest.runId}.`,

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

@@ -13,6 +13,8 @@ export interface RunDeadline {
 	deadlineMs: number;
 	/** Underlying controller — callers may link additional parent signals. */
 	controller: AbortController;
+	/** RC-02: the deadline timer handle — callers clear it on normal completion. */
+	timer: NodeJS.Timeout | undefined;
 }
 
 /** Fallback deadline when no config or param override is available: 1 hour. */
@@ -58,9 +60,12 @@ export function resolveRunDeadline<T extends object>(
 		else ctx.signal.addEventListener("abort", () => controller.abort(), { once: true });
 	}
 	// Arm the deadline timer (unref'd so it never blocks process exit).
+	// RC-02: expose the timer so callers can clearTimeout on normal completion —
+	// otherwise every run leaves a dangling 1h timer retaining ctx/params in closure.
+	let timer: NodeJS.Timeout | undefined;
 	if (deadlineMs > 0) {
-		const timer = setTimeout(() => controller.abort(), deadlineMs);
+		timer = setTimeout(() => controller.abort(), deadlineMs);
 		timer.unref?.();
 	}
-	return { signal: controller.signal, deadlineMs, controller };
+	return { signal: controller.signal, deadlineMs, controller, timer };
 }

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

@@ -32,7 +32,7 @@ async function executeTeamRun(...args: Parameters<typeof ExecuteTeamRunFn>): Pro
 
 import { spawnBackgroundTeamRun } from "../../runtime/async-runner.ts";
 import { resolveCrewRuntime, runtimeResolutionState } from "../../runtime/model/runtime-resolver.ts";
-import { appendEventAsync, readEvents } from "../../state/event-log/event-log.ts";
+import { appendEventAsync, readEventsCursor } from "../../state/event-log/event-log.ts";
 import type { RunMetrics } from "../../state/stores/run-metrics.ts";
 import type { RuntimeResolutionState, TeamRunManifest, TeamTaskState } from "../../state/types.ts";
 
@@ -110,7 +110,7 @@ function scheduleBackgroundEarlyExitGuard(cwd: string, runId: string, pid: numbe
 		if (!loaded || !isActiveRunStatus(loaded.manifest.status)) return;
 		if (hasAsyncStartMarker(loaded.manifest)) return;
 		if (
-			readEvents(loaded.manifest.eventsPath).some(
+			readEventsCursor(loaded.manifest.eventsPath).events.some(
 				(event) => event.type === "async.started" || event.type === "async.completed" || event.type === "async.failed",
 			)
 		)
@@ -704,6 +704,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 			);
 		} finally {
 			unregisterActiveRun(dwfManifest.runId);
+			clearTimeout(dwfDeadline.timer); // RC-02
 		}
 	}
 
@@ -863,6 +864,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		// Wait for the async run to complete and return actual results.
 		try {
 			const completed = await waitForRun(updatedManifest.runId, resolvedCtx.cwd, { timeoutMs: asyncDeadline.deadlineMs });
+			clearTimeout(asyncDeadline.timer); // RC-02
 			return formatRunResult(completed.manifest, {
 				tasks: completed.tasks,
 				metrics: collectRunMetrics(resolvedCtx.cwd, completed.manifest.runId),
@@ -943,12 +945,22 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		// CORE-8: unified deadline — resolves params > config > 1h default.
 		const fgDeadline = resolveRunDeadline(ctx, params, executedConfig);
 		ctx.onRunStarted?.(updatedManifest.runId);
+		const fgSignal = fgDeadline.signal;
+		let fgAbortListener: (() => void) | undefined;
+		let fgCallbackSignal: AbortSignal | undefined;
 		ctx.startForegroundRun(async (signal) => {
 			// Link the foreground-run callback signal to the deadline controller
 			// so cancel-via-abortForegroundRun propagates to executeTeamRun.
-			if (signal && signal !== fgDeadline.signal) {
+			fgCallbackSignal = signal;
+			if (signal && signal !== fgSignal) {
 				if (signal.aborted) fgDeadline.controller.abort();
-				else signal.addEventListener("abort", () => fgDeadline.controller.abort(), { once: true });
+				else {
+					// RC-03: keep the ref so we can removeEventListener on completion (the
+					// {once:true} alone leaks on the success path — the listener stays
+					// attached to the long-lived callback signal if the deadline never fires).
+					fgAbortListener = () => fgDeadline.controller.abort();
+					signal.addEventListener("abort", fgAbortListener, { once: true });
+				}
 			}
 			try {
 				await executeTeamRun({
@@ -979,6 +991,11 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 				});
 			} finally {
 				unregisterActiveRun(updatedManifest.runId);
+				// RC-02/03: stop the deadline timer once the run's executeTeamRun completes
+				// (success or error). clearTimeout is idempotent — safe if already fired.
+				clearTimeout(fgDeadline.timer);
+				// Detach the abort listener from the callback signal (RC-03).
+				if (fgCallbackSignal && fgAbortListener) fgCallbackSignal.removeEventListener("abort", fgAbortListener);
 			}
 		}, updatedManifest.runId);
 
@@ -1047,6 +1064,8 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		});
 	} finally {
 		unregisterActiveRun(updatedManifest.runId);
+		// RC-02: clear the inline-path deadline timer (idempotent).
+		clearTimeout(inlineDeadline.timer);
 	}
 	return formatRunResult(executed.manifest, {
 		tasks: executed.tasks,

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

@@ -9,7 +9,7 @@ import { formatTaskGraphLines, waitingReason } from "../../runtime/task-display.
 import { verifyTaskCompletion } from "../../runtime/verification/completion-guard.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { readDeliveryState, readMailbox } from "../../state/coordination/mailbox.ts";
-import { appendEvent, readEvents } from "../../state/event-log/event-log.ts";
+import { appendEvent, readEventsCursor } from "../../state/event-log/event-log.ts";
 import { loadRunManifestById, saveRunTasks, updateRunStatus } from "../../state/stores/state-store.ts";
 import { aggregateUsage, formatCost, formatUsage } from "../../state/usage.ts";
 import { formatDuration } from "../../ui/format-helpers.ts";
@@ -64,7 +64,7 @@ export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiT
 	const counts = new Map<string, number>();
 	for (const task of tasks) counts.set(task.status, (counts.get(task.status) ?? 0) + 1);
 	const phaseProgress = computePhaseProgress(tasks);
-	const allEvents = readEvents(manifest.eventsPath);
+	const { events: allEvents } = readEventsCursor(manifest.eventsPath);
 	const events = allEvents.slice(-8);
 	// P1-8: pre-build the ack-timeout requestId set once (was O(events × messages)
 	// via allEvents.some() inside the mailbox loop).

package/src/extension/team-tool.ts

@@ -185,6 +185,51 @@ function artifactKey(artifact: ArtifactDescriptor): string {
 	return `${artifact.kind}:${artifact.path}`;
 }
 
+/** Optional numeric params that accept the empty-string unset marker AND
+ *  stringified numbers in their schema (Union with Literal("") + a numeric-string
+ *  pattern branch). pi-ai's tool-argument coercion sometimes stringifies a
+ *  numeric value (e.g. interval:0 → "0") when the schema Union has a
+ *  string-literal branch, so the schema accepts the string form (Value.Check
+ *  passes) but handlers expect real numbers (TeamToolParamsValue types them as
+ *  number). This converts the string form back to a number — and treats "" as
+ *  unset (deleted) — before any domain router reads the param. */
+const LOOSE_NUMERIC_PARAM_KEYS = ["interval", "budgetWarning", "budgetAbort", "tokenBudget", "replyDeadline"] as const;
+
+function normalizeLooseNumericFields(params: TeamToolParamsValue): TeamToolParamsValue {
+	let mutated = false;
+	const out: Record<string, unknown> = { ...params };
+	for (const key of LOOSE_NUMERIC_PARAM_KEYS) {
+		const v = out[key];
+		if (v === undefined || v === null) continue;
+		if (v === "") {
+			delete out[key];
+			mutated = true;
+			continue;
+		}
+		if (typeof v === "string") {
+			const n = Number(v);
+			if (Number.isFinite(n)) {
+				out[key] = n;
+				mutated = true;
+			} else {
+				delete out[key];
+				mutated = true;
+			}
+		}
+	}
+	// `once` is Union([Boolean, String, Number]); normalize its string form too.
+	if (typeof out.once === "string") {
+		if (out.once === "false") out.once = false;
+		else if (out.once === "true") out.once = true;
+		else {
+			const n = Number(out.once);
+			if (Number.isFinite(n)) out.once = n;
+		}
+		mutated = true;
+	}
+	return mutated ? (out as TeamToolParamsValue) : params;
+}
+
 async function recoverCheckpointedTasks(
 	manifest: TeamRunManifest,
 	tasks: TeamTaskState[],
@@ -296,7 +341,14 @@ 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 () => {
+	// LOCK-2 (Round 2): Lock held only for recovery + reset (the read-modify-write
+	// critical section). executeTeamRun runs OUTSIDE the lock — it uses
+	// team-runner's own per-operation withRunLock calls (mergeUnitResult,
+	// handleFailedTask merge, finalizeRun), mirroring handleRun (which never wraps
+	// executeTeamRun in an outer lock). Holding the resume lock across the
+	// minutes-long executeTeamRun would let any process steal the lock after
+	// DEFAULT_LOCKS.staleMs (30s) — see defaults.ts.
+	const decision = await withRunLock(loaded.manifest, async () => {
 		// R2: re-read inside the lock so recovery + resetTasks reflect committed
 		// state, not the pre-lock snapshot. Between the pre-lock load and lock
 		// acquisition a task may have been cancelled (stale-reconciler) or
@@ -354,23 +406,26 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 				message: blocked.summary,
 				data: { runtime, action: "resume" },
 			});
-			return result(
-				[
-					`Blocked resume for pi-crew run ${blocked.runId}: real subagent workers are disabled.`,
-					`Runtime: ${runtime.kind} (requested ${runtime.requestedMode})`,
-					runtime.reason ?? "Child worker execution is disabled.",
-					"",
-					"To resume effective subagents, remove executeWorkers=false / PI_CREW_EXECUTE_WORKERS=0 / PI_TEAMS_EXECUTE_WORKERS=0 or set runtime.mode=child-process.",
-					"Use runtime.mode=scaffold only for explicit dry-run prompt/artifact generation.",
-				].join("\n"),
-				{
-					action: "resume",
-					status: "error",
-					runId: blocked.runId,
-					artifactsRoot: blocked.artifactsRoot,
-				},
-				true,
-			);
+			return {
+				kind: "blocked" as const,
+				payload: result(
+					[
+						`Blocked resume for pi-crew run ${blocked.runId}: real subagent workers are disabled.`,
+						`Runtime: ${runtime.kind} (requested ${runtime.requestedMode})`,
+						runtime.reason ?? "Child worker execution is disabled.",
+						"",
+						"To resume effective subagents, remove executeWorkers=false / PI_CREW_EXECUTE_WORKERS=0 / PI_TEAMS_EXECUTE_WORKERS=0 or set runtime.mode=child-process.",
+						"Use runtime.mode=scaffold only for explicit dry-run prompt/artifact generation.",
+					].join("\n"),
+					{
+						action: "resume",
+						status: "error",
+						runId: blocked.runId,
+						artifactsRoot: blocked.artifactsRoot,
+					},
+					true,
+				),
+			};
 		}
 		const resetTasks = recovered.tasks.map((task) =>
 			task.status === "failed" || task.status === "cancelled" || task.status === "skipped" || task.status === "running"
@@ -413,42 +468,59 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 			});
 		const executeWorkers = runtime.kind !== "scaffold";
 		const resumeSkillOverride = normalizeSkillOverride(params.skill) ?? runtimeManifest.skillOverride;
-		const executed = await executeTeamRun({
-			manifest: runtimeManifest,
-			tasks: resetTasks,
-			team,
-			workflow,
-			agents,
+
+		return {
+			kind: "execute" as const,
+			runtimeManifest,
+			resetTasks,
 			executeWorkers,
-			limits: executedConfig.limits,
+			resumeSkillOverride,
 			runtime,
-			runtimeConfig: executedConfig.runtime,
-			parentContext: buildParentContext(ctx),
-			parentModel: ctx.model,
-			modelRegistry: ctx.modelRegistry,
-			modelOverride: params.model,
-			skillOverride: resumeSkillOverride,
-			signal: ctx.signal,
-			reliability: executedConfig.reliability,
-			metricRegistry: ctx.metricRegistry,
-			workspaceId: ctx.sessionId ?? ctx.cwd,
-		});
-		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",
-		);
+			executedConfig,
+		};
+	});
+
+	// Lock is now RELEASED. executeTeamRun runs without holding the resume
+	// lock — it uses team-runner's own per-operation withRunLock calls
+	// (mergeUnitResult, handleFailedTask merge, finalizeRun), mirroring
+	// handleRun (which never wraps executeTeamRun in an outer lock).
+	if (decision.kind === "blocked") return decision.payload;
+
+	const executed = await executeTeamRun({
+		manifest: decision.runtimeManifest,
+		tasks: decision.resetTasks,
+		team,
+		workflow,
+		agents,
+		executeWorkers: decision.executeWorkers,
+		limits: decision.executedConfig.limits,
+		runtime: decision.runtime,
+		runtimeConfig: decision.executedConfig.runtime,
+		parentContext: buildParentContext(ctx),
+		parentModel: ctx.model,
+		modelRegistry: ctx.modelRegistry,
+		modelOverride: params.model,
+		skillOverride: decision.resumeSkillOverride,
+		signal: ctx.signal,
+		reliability: decision.executedConfig.reliability,
+		metricRegistry: ctx.metricRegistry,
+		workspaceId: ctx.sessionId ?? ctx.cwd,
 	});
+	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 handleSteer(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
@@ -626,6 +698,9 @@ export async function handleTeamTool(params: TeamToolParamsValue, ctx: TeamConte
 	// a missing action defaulted to "list" at the facade but the router read
 	// params.action=undefined → "Unhandled status-domain action: undefined".
 	params = { ...params, action: params.action ?? "list" };
+	// Coerce stringified-numeric params (pi-ai coercion artifact) back to real
+	// numbers before domain routers read them. See normalizeLooseNumericFields.
+	params = normalizeLooseNumericFields(params);
 	const action = params.action ?? "list";
 	const domain = domainForAction(action);
 	switch (domain) {

package/src/runtime/background-runner.ts

@@ -110,6 +110,38 @@ function argValue(name: string): string | undefined {
 	return process.argv[index + 1];
 }
 
+/**
+ * Signals the catch-all loop registers that do NOT terminate the background
+ * runner (SIGWINCH = terminal resize, SIGPIPE = closed pipe, SIGCONT etc.).
+ * Logging these as fatal `async.failed` poisons dead-run detection:
+ * async-notifier's isAsyncTerminalEvent treats async.failed as terminal, so a
+ * single benign signal (e.g. a terminal resize) would permanently disable
+ * markDeadAsyncRunIfNeeded for the run. Benign signals are logged as
+ * non-terminal `async.signal` instead.
+ */
+export const BENIGN_SIGNALS = new Set([
+	"SIGWINCH",
+	"SIGPIPE",
+	"SIGCONT",
+	"SIGTSTP",
+	"SIGTTIN",
+	"SIGTTOU",
+	"SIGURG",
+	"SIGPROF",
+	"SIGVTALRM",
+	"SIGALRM",
+	"SIGIO",
+	"SIGPWR",
+]);
+
+/**
+ * Classify a caught signal as terminal (`async.failed` — the process is
+ * dying) or benign (`async.signal` — the process keeps running).
+ */
+export function signalEventType(sig: string): "async.signal" | "async.failed" {
+	return BENIGN_SIGNALS.has(sig) ? "async.signal" : "async.failed";
+}
+
 /**
  * Fire-and-forget event log for signal handlers. Extracted to module level
  * (from inside main()) so the exported SIGINT handler installer (test seam)
@@ -119,10 +151,12 @@ function argValue(name: string): string | undefined {
 function signalLog(sig: string, eventsPath: string): void {
 	const runId = argValue("--run-id");
 	if (runId && eventsPath) {
+		const type = signalEventType(sig);
 		appendEventFireAndForget(eventsPath, {
-			type: "async.failed",
+			type,
 			runId,
-			message: `Background runner received ${sig} — exiting.`,
+			// Benign signals don't exit the runner — don't claim they do.
+			message: type === "async.failed" ? `Background runner received ${sig} — exiting.` : `Background runner received ${sig}.`,
 			data: { signal: sig, pid: process.pid },
 		});
 	}

package/src/runtime/delivery-coordinator.ts

@@ -7,6 +7,11 @@ export interface PendingDelivery {
 	timestamp: number;
 	type: "result" | "notification" | "steer";
 	generation?: number;
+	/** Pi session that owns the underlying run. Set at enqueue time; a delivery
+	 * whose ownerSessionId differs from the currently active session is parked
+	 * (not flushed) so queued results never leak into the wrong session after an
+	 * in-process session switch (vector #12). Absent = ownerless/legacy (always flush). */
+	ownerSessionId?: string;
 }
 
 export interface DeliveryCoordinatorDeps {
@@ -28,6 +33,9 @@ export class DeliveryCoordinator {
 	private readonly deps: DeliveryCoordinatorDeps;
 	private ttlTimer: ReturnType<typeof setInterval> | undefined;
 	private timerStarted = false;
+	/** The session id passed to the most recent activate(); used by flushQueuedResults
+	 * to park deliveries owned by a different session (vector #12). */
+	private activeSessionId?: string;
 
 	constructor(deps: DeliveryCoordinatorDeps) {
 		this.deps = deps;
@@ -35,6 +43,7 @@ export class DeliveryCoordinator {
 
 	activate(sessionId: string): void {
 		this.active = true;
+		this.activeSessionId = sessionId;
 		this.flushQueuedResults();
 	}
 
@@ -51,7 +60,7 @@ export class DeliveryCoordinator {
 		return this.pending.length;
 	}
 
-	deliverResult(runId: string, result: unknown): void {
+	deliverResult(runId: string, result: unknown, ownerSessionId?: string): void {
 		if (this.active && this.deps.emit) {
 			try {
 				this.deps.emit("pi-crew:run-result", result);
@@ -66,10 +75,11 @@ export class DeliveryCoordinator {
 				payload: result,
 				timestamp: Date.now(),
 				type: "result",
+				ownerSessionId,
 			});
 	}
 
-	deliverNotification(notification: NotificationDescriptor): void {
+	deliverNotification(notification: NotificationDescriptor, ownerSessionId?: string): void {
 		let delivered = false;
 		if (this.active && this.deps.sendFollowUp) {
 			try {
@@ -95,10 +105,11 @@ export class DeliveryCoordinator {
 				payload: notification,
 				timestamp: Date.now(),
 				type: "notification",
+				ownerSessionId,
 			});
 	}
 
-	deliverSteer(runId: string, message: string): void {
+	deliverSteer(runId: string, message: string, ownerSessionId?: string): void {
 		if (this.active && this.deps.sendWakeUp) {
 			try {
 				this.deps.sendWakeUp(message);
@@ -113,6 +124,7 @@ export class DeliveryCoordinator {
 				payload: message,
 				timestamp: Date.now(),
 				type: "steer",
+				ownerSessionId,
 			});
 	}
 
@@ -127,6 +139,15 @@ export class DeliveryCoordinator {
 		try {
 			const retryLater: PendingDelivery[] = [];
 			for (const delivery of batch) {
+				// Vector #12: park deliveries owned by a session other than the one
+				// currently active. They must never flush into the wrong session after
+				// an in-process session switch. Re-queued as-is (generation preserved)
+				// so the existing stale-steer check still applies when the owning
+				// session becomes active again.
+				if (delivery.ownerSessionId && this.activeSessionId && delivery.ownerSessionId !== this.activeSessionId) {
+					retryLater.push(delivery);
+					continue;
+				}
 				if (delivery.type === "steer" && delivery.generation !== undefined && delivery.generation !== this.generation) {
 					logInternalError("delivery-coordinator.flush.stale", undefined, `runId=${delivery.runId} type=${delivery.type}`);
 					continue;

package/src/runtime/foreground-watchdog.ts

@@ -41,8 +41,8 @@ export function stopWatchdog(runId: string): void {
 	}
 }
 
-/** @internal Stop all active watchdogs. Called on session shutdown. */
-function stopAllWatchdogs(): void {
+/** @internal Stop all active watchdogs. Called on session shutdown (RC-01). */
+export function stopAllWatchdogs(): void {
 	for (const [runId, timer] of activeWatchdogs) {
 		clearTimeout(timer);
 	}