pi-crew 0.11.0 → 0.11.2

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

@@ -105,12 +105,22 @@ export function registerDashboardCommands(pi: ExtensionAPI, deps: RegisterTeamCo
 	pi.registerCommand("team-dashboard", {
 		description: "Open a pi-crew run dashboard overlay",
 		handler: async (_args: string, ctx: ExtensionCommandContext) => {
+			// W4 (slash-commands fix spec): headless invocation previously fell
+			// through to openTeamDashboard's silent `if (!ctx.hasUI) return;`
+			// no-op — notify + return here instead so headless users get an
+			// actionable pointer instead of silence.
+			if (!ctx.hasUI) {
+				ctx.ui.notify("team-dashboard needs a UI session — headless runs can use /team-status instead.", "info");
+				return;
+			}
 			await openTeamDashboard(ctx);
 		},
 	});
 
 	pi.registerCommand("team-mascot", {
-		description: "Show an animated mascot splash",
+		// W4: cosmetic command is a documented silent no-op without a UI
+		// session (handler's `if (!ctx.hasUI) return;` stays).
+		description: "Show an animated mascot splash (UI session only)",
 		handler: async (args: string, ctx: ExtensionCommandContext) => {
 			if (!ctx.hasUI) return;
 			const tokens = args.trim().split(/\s+/).filter(Boolean);

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 {
@@ -278,22 +294,23 @@ export function registerManageCommands(pi: ExtensionAPI, deps: RegisterTeamComma
 	});
 
 	pi.registerCommand("crew-brief", {
-		description: "Toggle brief tool output mode: on | off | status",
+		description:
+			"Toggle brief mode for crew `team`/`agent` tool output (native read/bash/edit/write/find/grep/ls output is unaffected): on | off | status",
 		handler: async (args: string, ctx: ExtensionCommandContext) => {
 			// LAZY: defer dynamic import of ../../ui/tool-renderers/brief-mode.ts to its call site. Multi-line form breaks scripts/check-lazy-imports.mjs (which does `lines[lineNum - 2]`), so keep destructuring + await import on one line and place this LAZY marker directly above.
-			const { isBrief, setBrief, BRIEF_ENTRY_TYPE, makeBriefEntry } = await import("../../../ui/tool-renderers/brief-mode.ts");
+			const { isBrief, setBrief, BRIEF_ENTRY_TYPE } = await import("../../../ui/tool-renderers/brief-mode.ts");
 			const trimmed = args.trim();
 
 			if (trimmed === "on") {
 				setBrief(true);
 				pi.appendEntry(BRIEF_ENTRY_TYPE, { enabled: true });
-				ctx.ui.notify("Brief mode: on — tool output will show compact summaries", "info");
+				ctx.ui.notify("Brief mode: on — crew team/agent tool output will show compact summaries", "info");
 				return;
 			}
 			if (trimmed === "off") {
 				setBrief(false);
 				pi.appendEntry(BRIEF_ENTRY_TYPE, { enabled: false });
-				ctx.ui.notify("Brief mode: off — full tool output restored", "info");
+				ctx.ui.notify("Brief mode: off — full crew team/agent tool output restored", "info");
 				return;
 			}
 			// status (default)

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

@@ -531,7 +531,6 @@ export async function openTeamDashboard(ctx: ExtensionContext): Promise<void> {
 		const selection = await cmdCtx.ui.custom<RunDashboardSelection | undefined>(
 			(tui, theme, _keybindings, done) =>
 				new RunDashboard(runs, done, theme, {
-					placement: rightPanel ? "right" : "center",
 					showModel: uiConfig?.showModel,
 					showTokens: uiConfig?.showTokens,
 					showTools: uiConfig?.showTools,
@@ -577,6 +576,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/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,32 @@ 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 {
+				reconcileAllStaleRuns(current.cwd, ctx.getManifestCache(current.cwd), undefined, extractSessionId(current));
+			} catch (error) {
+				logInternalError("register.autoRepair.turnHook", error);
+			}
+		});
+	} catch {
+		/* older Pi without before_agent_start — rely on the interval alone */
+	}
 }
 
 /**
@@ -58,6 +85,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 +98,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 +121,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 +141,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 +151,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);