pi-crew 0.11.1 → 0.11.4

package/src/extension/registration/commands/manage.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { fileURLToPath } from "node:url";
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { getBuiltinTemplates, instantiateTemplate, listTemplates } from "../../../skills/skill-templates.ts";
 import { atomicWriteFile } from "../../../state/atomic-write.ts";
@@ -9,6 +10,29 @@ import { commandText, notifyCommandResult, parseScalar, pushUnset, setNestedConf
 import type { RegisterTeamCommandsDeps } from "./shared.ts";
 import { handleTeamTool, openTeamSettingsOverlay, teamCommandContext } from "./shared.ts";
 
+/**
+ * Resolve the user-level skills directory (<pi-crew package root>/skills).
+ *
+ * ESM-safe replacement for the former `require.resolve("../../../../package.json",
+ * { paths: [__dirname] })`: neither `require` nor `__dirname` exists under
+ * strip-types source loading or inside the esbuild ESM bundle (dist/index.mjs).
+ * Anchoring on `import.meta.url` and walking up to the nearest package.json
+ * yields the package root under BOTH layouts — src/.../commands/manage.ts and
+ * dist/index.mjs sit at different depths, so a fixed relative hop count cannot
+ * serve both.
+ */
+export function resolveUserSkillsDir(): string {
+	let dir = fileURLToPath(new URL(".", import.meta.url));
+	for (;;) {
+		if (fs.existsSync(path.join(dir, "package.json"))) return path.join(dir, "skills");
+		const parent = path.dirname(dir);
+		if (parent === dir) {
+			throw new Error(`pi-crew: cannot locate package root (no package.json above ${dir})`);
+		}
+		dir = parent;
+	}
+}
+
 export function registerManageCommands(pi: ExtensionAPI, deps: RegisterTeamCommandsDeps): void {
 	pi.registerCommand("team-prune", {
 		description: "Prune old finished pi-crew runs, keeping the newest N",
@@ -210,16 +234,20 @@ export function registerManageCommands(pi: ExtensionAPI, deps: RegisterTeamComma
 					return idx === -1 ? [s, ""] : [s.slice(0, idx), s.slice(idx + 1)];
 				});
 			const templateId = tokens.find((t) => !t.startsWith("--") && !t.includes("="));
+			const availableTemplateIds = listTemplates().map((t) => t.id);
 			if (!templateId) {
 				await notifyCommandResult(
 					ctx,
-					"Usage: /skill-create <template-id> [--var key=value...] [--project]\nRun /skill-list to see available templates.",
+					`Usage: /skill-create <template-id> [--var key=value...] [--project]\nAvailable templates: ${availableTemplateIds.join(", ")}`,
 				);
 				return;
 			}
 			const template = getBuiltinTemplates().find((t) => t.id === templateId);
 			if (!template) {
-				await notifyCommandResult(ctx, `Unknown template '${templateId}'. Run /skill-list to see available templates.`);
+				await notifyCommandResult(
+					ctx,
+					`Unknown template '${templateId}'.\nUsage: /skill-create <template-id> [--var key=value...] [--project]\nAvailable templates: ${availableTemplateIds.join(", ")}`,
+				);
 				return;
 			}
 			const variables: Record<string, string> = {};
@@ -249,19 +277,7 @@ export function registerManageCommands(pi: ExtensionAPI, deps: RegisterTeamComma
 				await notifyCommandResult(ctx, error instanceof Error ? error.message : String(error));
 				return;
 			}
-			const skillsDir = path.resolve(
-				cwd,
-				useProject
-					? "skills"
-					: path.join(
-							path.dirname(
-								require.resolve("../../../../package.json", {
-									paths: [__dirname],
-								}),
-							),
-							"skills",
-						),
-			);
+			const skillsDir = useProject ? path.resolve(cwd, "skills") : resolveUserSkillsDir();
 			const skillDir = path.join(skillsDir, template.id);
 			const skillPath = path.join(skillDir, "SKILL.md");
 			try {

package/src/extension/registration/commands/run.ts

@@ -109,6 +109,10 @@ export function registerRunCommands(pi: ExtensionAPI, deps: RegisterTeamCommands
 			const taskToken = tokens[0] === "--all" ? tokens.shift() : tokens.shift();
 			const taskId = taskToken === "--all" ? undefined : taskToken;
 			const message = tokens.join(" ") || undefined;
+			if (!runId || !taskToken || !message) {
+				await notifyCommandResult(ctx, "Usage: /team-respond <runId> <taskId|--all> <message>…");
+				return;
+			}
 			const result = await handleTeamTool({ action: "respond", runId, taskId, message }, teamCommandContext(ctx));
 			await notifyCommandResult(ctx, commandText(result));
 		},
@@ -163,7 +167,19 @@ export function registerRunCommands(pi: ExtensionAPI, deps: RegisterTeamCommands
 
 	pi.registerCommand("team-goal", {
 		description:
-			"Autonomous goal loop control: [start|status|pause|resume|stop|step|clear] [goalId] [--objective=...] [--evaluatorModel=...] [--maxTurns=N]",
+			"Autonomous goal loop control (defaults to status): [start|status|pause|resume|stop|cancel|reset|step|clear] [goalId] [--objective=...] [--evaluatorModel=...] [--maxTurns=N]",
+		// Suggest the stop-aliases only while completing the FIRST argument:
+		// pi hands `getArgumentCompletions` the whole argument text (there is no
+		// argument-index parameter), so any whitespace in it means the cursor is
+		// already past arg 1 — nothing useful to suggest for goalId/flags.
+		getArgumentCompletions: (argumentPrefix: string) => {
+			if (argumentPrefix.includes(" ")) return [];
+			const prefix = argumentPrefix.trim();
+			return [
+				{ value: "cancel", label: "cancel", description: "stop the goal loop (alias of stop)" },
+				{ value: "reset", label: "reset", description: "stop the goal loop (alias of stop)" },
+			].filter((item) => item.value.startsWith(prefix));
+		},
 		handler: async (args: string, ctx: ExtensionCommandContext) => {
 			const tokens = args.trim().split(/\s+/).filter(Boolean);
 			const knownSubs = new Set(["start", "status", "pause", "resume", "stop", "step", "clear", "cancel", "reset"]);
@@ -203,7 +219,13 @@ export function registerRunCommands(pi: ExtensionAPI, deps: RegisterTeamCommands
 					metricRegistry: deps.getMetricRegistry?.(),
 				},
 			);
-			await notifyCommandResult(ctx, commandText(result));
+			const text = commandText(result);
+			const trimmed = text.trim();
+			const hint =
+				!trimmed || trimmed === "[]"
+					? "\nNo metrics yet — observability may be disabled for this team. Set `observability: true` in the team frontmatter to enable."
+					: "";
+			await notifyCommandResult(ctx, text + hint);
 		},
 	});
 

package/src/extension/registration/commands/shared.ts

@@ -46,6 +46,7 @@ export async function handleTeamTool(
 	if (!_cachedHandleTeamTool) {
 		if (!_handleTeamToolPromise) {
 			_handleTeamToolPromise = import("../../team-tool.ts").then((mod) => {
+				// LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
 				_cachedHandleTeamTool = mod.handleTeamTool;
 				return mod.handleTeamTool;
 			});
@@ -109,13 +110,13 @@ export async function ui(): Promise<NonNullable<typeof _uiCache>> {
 		if (!_uiCachePromise) {
 			_uiCachePromise = (async () => {
 				const [rd, tv, co, md, mc, ap, ma] = await Promise.all([
-					import("../../../ui/run-dashboard.ts"),
-					import("../../../ui/transcript-viewer.ts"),
-					import("../../../ui/overlays/confirm-overlay.ts"),
-					import("../../../ui/overlays/mailbox-detail-overlay.ts"),
-					import("../../../ui/overlays/mailbox-compose-overlay.ts"),
-					import("../../../ui/overlays/agent-picker-overlay.ts"),
-					import("../../../ui/mascot.ts"),
+					import("../../../ui/run-dashboard.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
+					import("../../../ui/transcript-viewer.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
+					import("../../../ui/overlays/confirm-overlay.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
+					import("../../../ui/overlays/mailbox-detail-overlay.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
+					import("../../../ui/overlays/mailbox-compose-overlay.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
+					import("../../../ui/overlays/agent-picker-overlay.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
+					import("../../../ui/mascot.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
 				]);
 				const cache = {
 					RunDashboard: rd.RunDashboard,
@@ -249,9 +250,9 @@ export function teamCommandContext(ctx: ExtensionCommandContext): ExtensionComma
 export async function openTeamSettingsOverlay(ctx: ExtensionContext): Promise<void> {
 	if (!ctx.hasUI) return;
 	const [{ updateConfig, parseConfig }, { asCrewTheme }, { createSettingsOverlay }] = await Promise.all([
-		import("../../../config/config.ts"),
-		import("../../../ui/theme-adapter.ts"),
-		import("../../../ui/settings-overlay.ts"),
+		import("../../../config/config.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
+		import("../../../ui/theme-adapter.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
+		import("../../../ui/settings-overlay.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
 	]);
 	const loaded = loadConfig(ctx.cwd);
 	const config = loaded.config as Record<string, unknown>;
@@ -576,6 +577,29 @@ export async function openTeamDashboard(ctx: ExtensionContext): Promise<void> {
 			deps.getRunSnapshotCache?.(cmdCtx.cwd).invalidate(selection.runId);
 			continue;
 		}
+		// US-020: dashboard `x` cancel — dispatches the EXISTING cancel channel
+		// (control-domain handleCancel). The 2-step dashboard gate is the user's
+		// explicit intent; `intent` satisfies requireIntentForDestructiveActions
+		// when that policy is on. Dashboard reopens on continue (selection kept).
+		if (selection.action === "cancel" && selection.runId) {
+			// F4 pattern: surface backend rejections at error level, truncate long text.
+			const cancelResult = await handleTeamTool(
+				{
+					action: "cancel",
+					runId: selection.runId,
+					config: { intent: "dashboard cancel keystroke (2-step confirm)" },
+				},
+				teamCommandContext(cmdCtx),
+			);
+			const cancelText = commandText(cancelResult);
+			depsNotify(
+				cmdCtx,
+				cancelText.length > 800 ? `${cancelText.slice(0, 797)}...` : cancelText,
+				cancelResult.isError ? "error" : "info",
+			);
+			deps.getRunSnapshotCache?.(cmdCtx.cwd).invalidate(selection.runId);
+			continue;
+		}
 		if (selection.action === "plan-approve" || selection.action === "plan-deny") {
 			await handlePlanDashboardAction(cmdCtx, selection);
 			deps.getRunSnapshotCache?.(cmdCtx.cwd).invalidate(selection.runId);

package/src/extension/registration/commands/status.ts

@@ -1,10 +1,28 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { loadRunManifestById } from "../../../state/stores/state-store.ts";
 import { suggestRunIds } from "../../command-completions.ts";
 import { piTeamsHelp } from "../../help.ts";
-import { commandText, notifyCommandResult } from "../command-utils.ts";
+import { commandText, NOTIFY_TEXT_CAP, notifyCommandResult } from "../command-utils.ts";
 import type { RegisterTeamCommandsDeps } from "./shared.ts";
 import { handleTeamTool, teamCommandContext } from "./shared.ts";
 
+/**
+ * W5 (slash-commands fix spec): `/team-events` pointer. When the events
+ * listing is about to be clipped by the 800-char notification cap, resolve
+ * the run's on-disk events log so the message can end with a reachable path.
+ * Derived from the SAME source the `events` team action reads
+ * (inspect.ts): locateRunCwd + loadRunManifestById → manifest.eventsPath.
+ * The dynamic team-tool import is free here — the awaited handleTeamTool
+ * call above it already loaded that module into the ESM cache.
+ */
+async function eventsLogFooter(runId: string | undefined, text: string, cwd: string): Promise<string | undefined> {
+	if (!runId || text.length <= NOTIFY_TEXT_CAP) return undefined;
+	const { locateRunCwd } = await import("../../team-tool.ts"); // LAZY: defer team-tool chain to call site (handleTeamTool already cached it).
+	const runCwd = locateRunCwd(runId, cwd);
+	const manifest = runCwd ? loadRunManifestById(runCwd, runId)?.manifest : undefined;
+	return manifest ? ` Full log: ${manifest.eventsPath}` : undefined;
+}
+
 export function registerStatusCommands(pi: ExtensionAPI, deps: RegisterTeamCommandsDeps): void {
 	pi.registerCommand("teams", {
 		description: "List pi-crew teams, workflows, and agents",
@@ -34,7 +52,12 @@ export function registerStatusCommands(pi: ExtensionAPI, deps: RegisterTeamComma
 						getRunSnapshotCache: deps.getRunSnapshotCache,
 					},
 				);
-				await notifyCommandResult(ctx, commandText(result));
+				const text = commandText(result);
+				await notifyCommandResult(ctx, text, {
+					// W5: only `team-events` output is a truncatable on-disk log —
+					// point at the full file when the listing gets clipped.
+					truncatedFooter: action === "events" ? await eventsLogFooter(runId, text, ctx.cwd) : undefined,
+				});
 			},
 		});
 	}

package/src/extension/registration/context-builder.ts

@@ -58,6 +58,7 @@ export function buildRegistrationContext(pi: ExtensionAPI): RegistrationContext
 			autoRepairTimer: undefined,
 			tempReconcileTimer: undefined,
 			otlpExporter: undefined,
+			initPromise: undefined,
 		} as ObservabilityState,
 		lifecycleState: {
 			notifierStarted: false,
@@ -121,7 +122,12 @@ export function buildRegistrationContext(pi: ExtensionAPI): RegistrationContext
 	};
 
 	ctx.getManifestCache = (cwd: string) => {
-		if (ctx.manifestCache && ctx.cacheCwd === cwd) return ctx.manifestCache;
+		// F13 (RR-018): a disposed cache pair must be recreated EVEN WHEN the cwd
+		// is unchanged. Session cleanup disposes the caches but used to leave
+		// `cacheCwd` pointing at them, so same-cwd access returned the disposed
+		// instance (no disposed flag existed). isDisposed() makes the pair's
+		// liveness part of the swap check.
+		if (ctx.manifestCache && ctx.cacheCwd === cwd && !ctx.runSnapshotCache.isDisposed()) return ctx.manifestCache;
 		if (ctx.manifestCache) ctx.manifestCache.dispose();
 		if (ctx.runSnapshotCache) ctx.runSnapshotCache.dispose?.();
 		ctx.cacheCwd = cwd;
@@ -130,7 +136,7 @@ export function buildRegistrationContext(pi: ExtensionAPI): RegistrationContext
 		return ctx.manifestCache;
 	};
 	ctx.getRunSnapshotCache = (cwd: string) => {
-		if (ctx.cacheCwd !== cwd) ctx.getManifestCache(cwd);
+		if (ctx.cacheCwd !== cwd || ctx.runSnapshotCache.isDisposed()) ctx.getManifestCache(cwd);
 		return ctx.runSnapshotCache;
 	};
 

package/src/extension/registration/foreground-run-controller.ts

@@ -103,7 +103,7 @@ function startForegroundRunImpl(
 		extensionCtx.ui.setWorkingMessage(runId ? `pi-crew foreground run ${runId}...` : "pi-crew foreground run...");
 	}
 	if (runId) {
-		void import("../../runtime/foreground-watchdog.ts")
+		void import("../../runtime/foreground-watchdog.ts") // LAZY: defer watchdog module until first foreground run
 			.then(({ startForegroundWatchdog }) => {
 				startForegroundWatchdog({ pi, cwd: extensionCtx.cwd, runId });
 			})
@@ -139,7 +139,7 @@ function startForegroundRunImpl(
 			.finally(() => {
 				ctx.foregroundTeamRunControllers.delete(key);
 				if (runId) {
-					void import("../../runtime/foreground-watchdog.ts")
+					void import("../../runtime/foreground-watchdog.ts") // LAZY: defer watchdog module until first foreground run
 						.then(({ stopWatchdog }) => {
 							stopWatchdog(runId);
 						})

package/src/extension/registration/health-notify-policy.ts

@@ -0,0 +1,100 @@
+/**
+ * health-notify-policy.ts — FINDING 6 (2026-09-23 battery): ambient
+ * notification re-delivery storms.
+ *
+ * Observed live: a zombie-run leak made the health monitor re-fire the same
+ * `recovery_missing_heartbeat` notification every cooldown window (5 min) for
+ * hours. Each fire queued a follow-up message on the host session while the
+ * parent was busy; the host drains follow-ups ONE PER TURN BOUNDARY
+ * (followUpMode "one-at-a-time"), so the queued duplicates kept dripping into
+ * the parent conversation for ~5 hours AFTER the runs were deleted and the
+ * monitor had written its `clear` entries.
+ *
+ * Policy fixes (both sides of the storm):
+ *  1. BOUNDED RE-FIRE — a given notification key may fire at most
+ *     MAX_HEALTH_NOTIFY_FIRES times unless the underlying fingerprint changes
+ *     (a different dead/missing/task-count shape is a NEW situation and gets a
+ *     fresh budget). Previously the 5-min cooldown re-armed forever.
+ *  2. RESET-ON-CLEAR — the clear path resets the fire budget, so a genuine
+ *     recurrence after a resolved incident notifies again (up to the cap).
+ *
+ * The host-queue purge of already-queued copies is handled separately
+ * (purgeQueuedAmbientNotifications in subagent-helpers.ts) — this module only
+ * stops pi-crew from FEEDING the queue.
+ */
+
+/** Maximum notifications emitted per key before a fingerprint change. */
+export const MAX_HEALTH_NOTIFY_FIRES = 3;
+
+export interface AutoRecoveryEntry {
+	insertedAt: number;
+	lastAccessAt: number;
+	/** Times this key has fired under the current fingerprint. */
+	fires?: number;
+	/** Shape of the situation last notified (see healthNotifyFingerprint). */
+	fingerprint?: string;
+}
+
+export interface HealthNotifyState {
+	/** Map keyed `${kind}_${runId}` — typically ctx.autoRecoveryLast. */
+	entries: Map<string, AutoRecoveryEntry>;
+	/** LRU cap — typically ctx.AUTO_RECOVERY_LAST_MAX_ENTRIES. */
+	maxEntries: number;
+}
+
+/** Compact fingerprint of the health situation: same counts = same situation. */
+export function healthNotifyFingerprint(summary: { dead: number; missing: number }, totalTasks: number): string {
+	return `${summary.dead}/${summary.missing}/${totalTasks}`;
+}
+
+/**
+ * Decide whether a health notification may fire now, and record the decision.
+ *
+ * Fires when: (a) never fired before, (b) cooldown elapsed AND the same
+ * fingerprint still has budget, or (c) the fingerprint CHANGED (new situation
+ * — fresh budget). Blocks within the cooldown window and after the budget is
+ * exhausted. Evicts oldest-access entries at the cap (LRU, mirrors the
+ * previous inline behavior).
+ */
+export function recordHealthNotifyDecision(
+	state: HealthNotifyState,
+	key: string,
+	fingerprint: string,
+	now: number,
+	cooldownMs = 5 * 60_000,
+	maxFires = MAX_HEALTH_NOTIFY_FIRES,
+): boolean {
+	const previous = state.entries.get(key);
+	if (previous !== undefined && now - previous.lastAccessAt < cooldownMs) return false;
+	if (previous !== undefined && previous.fires !== undefined && previous.fires >= maxFires && previous.fingerprint === fingerprint) {
+		// Budget exhausted for an unchanged situation. Still refresh access so
+		// LRU ordering reflects interest in this key.
+		previous.lastAccessAt = now;
+		return false;
+	}
+	while (state.entries.size >= state.maxEntries) {
+		let oldestKey: string | undefined;
+		let oldestAccess = Infinity;
+		for (const [k, v] of state.entries) {
+			if (v.lastAccessAt < oldestAccess) {
+				oldestAccess = v.lastAccessAt;
+				oldestKey = k;
+			}
+		}
+		if (oldestKey === undefined) break;
+		state.entries.delete(oldestKey);
+	}
+	const fires = previous?.fingerprint === fingerprint ? (previous.fires ?? 0) + 1 : 1;
+	state.entries.set(key, {
+		insertedAt: previous?.insertedAt ?? now,
+		lastAccessAt: now,
+		fires,
+		fingerprint,
+	});
+	return true;
+}
+
+/** Reset a key's fire budget (clear path: resolved incident gets fresh budget). */
+export function resetHealthNotifyEntry(state: HealthNotifyState, key: string): void {
+	state.entries.delete(key);
+}

package/src/extension/registration/lazy-configurers.ts

@@ -24,6 +24,7 @@ import { reconcileAllStaleRuns } from "../../runtime/recovery/crash-recovery.ts"
 import { reconcileOrphanedTempWorkspaces } from "../../runtime/stale-reconciler.ts";
 import { requestPowerbarUpdate } from "../../ui/powerbar-publisher.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
+import { extractSessionId } from "../../utils/session-utils.ts";
 import type { RegistrationContext } from "./registration-types.ts";
 import { sendAgentWakeUp, sendFollowUp } from "./subagent-helpers.ts";
 
@@ -48,6 +49,35 @@ export function installLazyConfigurers(pi: ExtensionAPI, ctx: RegistrationContex
 	ctx.configureDeliveryCoordinator = (): void => {
 		void configureDeliveryCoordinatorImpl(pi, ctx);
 	};
+	installTurnReconcileHook(pi, ctx);
+}
+
+/**
+ * F12 (RR-018): register the before_agent_start reconcile hook EXACTLY ONCE
+ * for the extension lifetime. The callback resolves the CURRENT session
+ * (`ctx.currentCtx`) at fire time instead of capturing the configuring
+ * session's ExtensionContext, so a stale session's hook can never re-activate,
+ * double-reconcile a turn, or flip the shared manifest-cache cwd back to an
+ * old session's directory. (There is no pi.off unregister surface, so the old
+ * per-session registration accumulated one dead hook per session switch.)
+ */
+function installTurnReconcileHook(pi: ExtensionAPI, ctx: RegistrationContext): void {
+	try {
+		pi.on?.("before_agent_start", () => {
+			const current = ctx.currentCtx;
+			if (!current || ctx.cleanedUp) return;
+			try {
+				// RR-021 WI-1.5: async reconcile — fire-and-forget from the sync hook.
+				void reconcileAllStaleRuns(current.cwd, ctx.getManifestCache(current.cwd), undefined, extractSessionId(current)).catch(
+					(error) => logInternalError("register.autoRepair.turnHook", error),
+				);
+			} catch (error) {
+				logInternalError("register.autoRepair.turnHook", error);
+			}
+		});
+	} catch {
+		/* older Pi without before_agent_start — rely on the interval alone */
+	}
 }
 
 /**
@@ -58,6 +88,9 @@ export function installLazyConfigurers(pi: ExtensionAPI, ctx: RegistrationContex
  * `ctx.currentCtx` and caches.
  */
 async function configureNotificationsImpl(pi: ExtensionAPI, ctx: RegistrationContext, extCtx: ExtensionContext): Promise<void> {
+	// F11: capture the owning generation BEFORE the first await — the deps
+	// closure below re-checks it after lifecycle.ts's lazy imports resolve.
+	const ownerGeneration = ctx.sessionGeneration;
 	try {
 		// LAZY: registration/lifecycle is heavy (notification-router + sink)
 		const lifecycleModule = await import("./lifecycle.ts");
@@ -68,6 +101,7 @@ async function configureNotificationsImpl(pi: ExtensionAPI, ctx: RegistrationCon
 			getManifestCache: ctx.getManifestCache,
 			getRunSnapshotCache: ctx.getRunSnapshotCache,
 			requestPowerbarUpdate,
+			isOwnerSession: () => !ctx.cleanedUp && ctx.sessionGeneration === ownerGeneration,
 		});
 	} catch (error) {
 		logInternalError("register.configureNotifications", error);
@@ -90,6 +124,8 @@ async function configureObservabilityImpl(pi: ExtensionAPI, ctx: RegistrationCon
 			getManifestCache: ctx.getManifestCache,
 			notifyOperator: ctx.notifyOperator,
 			isCleanedUp: () => ctx.cleanedUp,
+			// F11: reuse the existing sessionGeneration counter — never a parallel one.
+			getSessionGeneration: () => ctx.sessionGeneration,
 			reconcileStaleRuns: (cwd, cache, currentSessionId) => reconcileAllStaleRuns(cwd, cache, undefined, currentSessionId),
 			reconcileOrphanedTempWorkspaces: (now, opts) => reconcileOrphanedTempWorkspaces(now, opts),
 			cleanupOrphanTempDirs,
@@ -108,6 +144,7 @@ async function configureObservabilityImpl(pi: ExtensionAPI, ctx: RegistrationCon
  * No dynamic import needed — lifecycle is already loaded by configureNotifications.
  */
 async function configureDeliveryCoordinatorImpl(pi: ExtensionAPI, ctx: RegistrationContext): Promise<void> {
+	const ownerGeneration = ctx.sessionGeneration;
 	try {
 		// LAZY: lifecycle.ts may not be loaded yet if configureNotifications hasn't fired.
 		const lifecycleModule = await import("./lifecycle.ts");
@@ -117,6 +154,7 @@ async function configureDeliveryCoordinatorImpl(pi: ExtensionAPI, ctx: Registrat
 			notifyOperator: ctx.notifyOperator,
 			sendFollowUp,
 			sendAgentWakeUp,
+			isOwnerSession: () => !ctx.cleanedUp && ctx.sessionGeneration === ownerGeneration,
 		});
 	} catch (error) {
 		logInternalError("register.configureDeliveryCoordinator", error);