@gajae-code/coding-agent 0.11.9 → 0.11.11

package/src/sdk/bus/telegram-daemon.ts

@@ -31,7 +31,7 @@ import {
 	releaseDaemonTransitionLock,
 	sanitizeDiagnostic,
 } from "./notification-service";
-import { DAEMON_GENERATION, NOTIFICATION_PROTOCOL_VERSION } from "./telegram-daemon-contract";
+import { DAEMON_GENERATION, NOTIFICATION_PROTOCOL_VERSION, SERVING_EPOCH } from "./telegram-daemon-contract";
 import {
 	type DaemonProcessReference,
 	type TelegramDaemonControlDeps,
@@ -39,7 +39,7 @@ import {
 } from "./telegram-daemon-control";
 import { type TelegramSetupPreflight, withTelegramSetupLease } from "./telegram-setup";
 
-export { DAEMON_GENERATION, NOTIFICATION_PROTOCOL_VERSION } from "./telegram-daemon-contract";
+export { DAEMON_GENERATION, NOTIFICATION_PROTOCOL_VERSION, SERVING_EPOCH } from "./telegram-daemon-contract";
 
 import {
 	buildButtonGrid,
@@ -132,6 +132,8 @@ export interface DaemonState {
 	 * notification wire protocol version. Absent on pre-generation state.
 	 */
 	generation?: number;
+	/** Lifecycle-serving compatibility epoch; absent pre-epoch records are epoch 1. */
+	servingEpoch?: number;
 	stoppedAt?: number;
 }
 export interface TelegramDaemonFs {
@@ -191,8 +193,20 @@ export const CLIENT_PING_PONG_CAPABILITY = "client_ping_pong";
 /** Capability required for typed controls and semantic Selected acknowledgement frames. */
 export const ASK_SELECTED_ACK_CAPABILITY = "ask_selected_ack_v1";
 export const ASK_CONTROLS_CAPABILITY = "ask_controls_v1";
-/** Capability required for tool lifecycle and reasoning-summary frames. */
-export const TOOL_ACTIVITY_CAPABILITY = "tool_activity_v1";
+/** Capability for the closed tool phase set: started, completed, failed, and cancelled. */
+export const TOOL_ACTIVITY_CAPABILITY = "tool_activity_v2";
+/** Receive-only compatibility capability for pre-v2 hosts. */
+export const LEGACY_TOOL_ACTIVITY_CAPABILITY = "tool_activity_v1";
+type ToolActivityCapability = "v1" | "v2";
+
+function negotiateToolActivityCapability(
+	current: ToolActivityCapability | undefined,
+	capabilities: unknown[],
+): ToolActivityCapability | undefined {
+	if (current === "v2" || capabilities.includes(TOOL_ACTIVITY_CAPABILITY)) return "v2";
+	if (current === "v1" || capabilities.includes(LEGACY_TOOL_ACTIVITY_CAPABILITY)) return "v1";
+	return undefined;
+}
 
 const nodeFs: TelegramDaemonFs = {
 	...(fs.promises as unknown as TelegramDaemonFs),
@@ -241,6 +255,18 @@ const RELOAD_FRESHNESS_WAIT_MS = 15_000;
 const RELOAD_CONTROLLER_GRACEFUL_MS = 8_000;
 const RELOAD_CONTROLLER_KILL_MS = 3_000;
 const RELOAD_RESERVATION_HEADROOM_MS = 10_000;
+const ROOTS_REGISTRATION_LOCK_RETRY_DELAY_MS = 100;
+const ROOTS_REGISTRATION_LOCK_HEADROOM_MS = 5_000;
+const ROOTS_REGISTRATION_LOCK_RETRIES =
+	Math.ceil(
+		(RELOAD_CONTROLLER_GRACEFUL_MS + RELOAD_CONTROLLER_KILL_MS + ROOTS_REGISTRATION_LOCK_HEADROOM_MS) /
+			ROOTS_REGISTRATION_LOCK_RETRY_DELAY_MS,
+	) + 1;
+const ROOTS_REGISTRATION_LOCK_OPTIONS = {
+	staleMs: 10_000,
+	retries: ROOTS_REGISTRATION_LOCK_RETRIES,
+	retryDelayMs: ROOTS_REGISTRATION_LOCK_RETRY_DELAY_MS,
+};
 
 /**
  * File-lock options whose acquisition budget covers the full reload-reservation
@@ -656,6 +682,162 @@ function ownershipLockMatchesState(lock: OwnershipLockRead, state: DaemonState |
 	);
 }
 
+type OwnerHeartbeatSidecar = {
+	pid: number;
+	incarnation: string;
+	ownerId: string;
+	acquisitionId: string;
+	heartbeatAt: number;
+};
+
+function ownerTagFromState(
+	state: DaemonState | undefined,
+): Pick<OwnerHeartbeatSidecar, "pid" | "incarnation" | "ownerId" | "acquisitionId"> | undefined {
+	if (
+		!state ||
+		!hasSafeDaemonStateShape(state) ||
+		state.stoppedAt !== undefined ||
+		!state.ownerId ||
+		!state.acquisitionId
+	)
+		return undefined;
+	return {
+		pid: state.pid,
+		incarnation: state.incarnation,
+		ownerId: state.ownerId,
+		acquisitionId: state.acquisitionId,
+	};
+}
+
+function sidecarMatchesOwnerTag(
+	sidecar: OwnerHeartbeatSidecar | undefined,
+	tag: Pick<OwnerHeartbeatSidecar, "pid" | "incarnation" | "ownerId" | "acquisitionId"> | undefined,
+): sidecar is OwnerHeartbeatSidecar {
+	return Boolean(
+		sidecar &&
+			tag &&
+			validDaemonPid(sidecar.pid) &&
+			isProcessIncarnation(sidecar.incarnation) &&
+			typeof sidecar.ownerId === "string" &&
+			typeof sidecar.acquisitionId === "string" &&
+			Number.isSafeInteger(sidecar.heartbeatAt) &&
+			sidecar.pid === tag.pid &&
+			sidecar.incarnation === tag.incarnation &&
+			sidecar.ownerId === tag.ownerId &&
+			sidecar.acquisitionId === tag.acquisitionId,
+	);
+}
+
+/**
+ * A corrupt, truncated, or otherwise unreadable sidecar must never break a
+ * freshness read: the sidecar is advisory-only, so any read/parse failure
+ * degrades to "no sidecar" (state-floor freshness), never a throw.
+ */
+async function readSidecarLenient(fsImpl: TelegramDaemonFs, file: string): Promise<OwnerHeartbeatSidecar | undefined> {
+	try {
+		const parsed: unknown = JSON.parse(await fsImpl.readFile(file, "utf8"));
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+			? (parsed as OwnerHeartbeatSidecar)
+			: undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export interface OwnerFreshnessSnapshot {
+	ownerTag: Pick<OwnerHeartbeatSidecar, "pid" | "incarnation" | "ownerId" | "acquisitionId"> | null;
+	effectiveHeartbeatAt: number | undefined;
+	legacyEmbedded: boolean;
+	state: DaemonState | undefined;
+}
+
+export async function readOwnerFreshnessSnapshot(input: {
+	settings: Settings;
+	fs?: TelegramDaemonFs;
+}): Promise<OwnerFreshnessSnapshot> {
+	const fsImpl = input.fs ?? nodeFs;
+	const paths = daemonPaths(input.settings.getAgentDir());
+	const state = await readJson<DaemonState>(fsImpl, paths.state);
+	const legacyEmbedded = Boolean(
+		state && (isGenerationAbsentParentDaemonState(state) || isGeneration3ReleaseDaemonState(state)),
+	);
+	const tag = ownerTagFromState(state);
+	const lock = await readOwnershipLock(fsImpl, paths.lock);
+	const ownerTag = tag && ownershipLockMatchesState(lock, state) ? tag : null;
+	if (legacyEmbedded) return { ownerTag, effectiveHeartbeatAt: state?.heartbeatAt, legacyEmbedded, state };
+	const sidecar = await readSidecarLenient(fsImpl, paths.heartbeat);
+	const rereadState = await readJson<DaemonState>(fsImpl, paths.state);
+	const rereadLock = await readOwnershipLock(fsImpl, paths.lock);
+	const rereadTag = ownerTagFromState(rereadState);
+	const stableTag = rereadTag && ownershipLockMatchesState(rereadLock, rereadState) ? rereadTag : null;
+	const stable =
+		ownerTag && stableTag && sidecarMatchesOwnerTag({ ...ownerTag, heartbeatAt: 0 }, stableTag) ? stableTag : null;
+	const effectiveHeartbeatAt = stable
+		? sidecarMatchesOwnerTag(sidecar, stable)
+			? Math.max(rereadState?.heartbeatAt ?? 0, sidecar.heartbeatAt)
+			: rereadState?.heartbeatAt
+		: undefined;
+	return {
+		ownerTag: stable,
+		effectiveHeartbeatAt,
+		legacyEmbedded: false,
+		state: rereadState,
+	};
+}
+
+/** Marker-free steady heartbeat renewal. The final lock reread fences a stale writer. */
+export async function renewOwnerHeartbeatSidecar(input: {
+	settings: Settings;
+	ownerId: string;
+	acquisitionId?: string;
+	fs?: TelegramDaemonFs;
+	now?: () => number;
+	pid?: number;
+	pidIncarnation?: (pid: number) => string | undefined;
+}): Promise<boolean> {
+	const fsImpl = input.fs ?? nodeFs;
+	const paths = daemonPaths(input.settings.getAgentDir());
+	const state = await readJson<DaemonState>(fsImpl, paths.state);
+	const pid = input.pid ?? state?.pid;
+	const incarnation = (input.pidIncarnation ?? defaultPidIncarnation)(pid ?? 0);
+	const acquisitionId = input.acquisitionId ?? input.ownerId;
+	if (
+		!state ||
+		!validDaemonPid(pid) ||
+		!isProcessIncarnation(incarnation) ||
+		state.pid !== pid ||
+		state.incarnation !== incarnation ||
+		state.ownerId !== input.ownerId ||
+		state.acquisitionId !== acquisitionId ||
+		state.stoppedAt !== undefined
+	)
+		return false;
+	const sidecar: OwnerHeartbeatSidecar = {
+		pid,
+		incarnation,
+		ownerId: input.ownerId,
+		acquisitionId,
+		heartbeatAt: (input.now ?? Date.now)(),
+	};
+	const tmp = `${paths.heartbeat}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+	await fsImpl.writeFile(tmp, `${JSON.stringify(sidecar, null, 2)}\n`, { mode: 0o600 });
+	await fsImpl.chmod(tmp, 0o600).catch(() => undefined);
+	const lock = await readOwnershipLock(fsImpl, paths.lock);
+	if (!ownershipLockMatchesState(lock, state)) {
+		await fsImpl.unlink(tmp).catch(() => undefined);
+		return false;
+	}
+	// Revalidate the exact lock after the temporary sidecar exists so a stale
+	// writer cannot publish after ownership moved during its write.
+	const finalLock = await readOwnershipLock(fsImpl, paths.lock);
+	if (!ownershipLockMatchesState(finalLock, state)) {
+		await fsImpl.unlink(tmp).catch(() => undefined);
+		return false;
+	}
+	await fsImpl.rename(tmp, paths.heartbeat);
+	return true;
+}
+
 function ownershipLockMatchesStoppedState(
 	lock: OwnershipLockRead,
 	state: unknown,
@@ -800,23 +982,29 @@ async function ownershipLockIsReclaimable(input: {
 	);
 }
 
-interface NotificationRootRegistration {
+export interface NotificationRootRegistration {
 	root?: string;
 	managed?: boolean;
+	token?: string;
 }
 
-async function readNotificationRootRegistration(input: {
+export async function readNotificationRootRegistration(input: {
 	settings: Settings;
 	sessionId: string;
 	fs?: TelegramDaemonFs;
 }): Promise<NotificationRootRegistration> {
 	const fsImpl = input.fs ?? nodeFs;
-	const current = await readJson<{ sessions?: Record<string, string>; managedRoots?: string[] }>(
-		fsImpl,
-		daemonPaths(input.settings.getAgentDir()).roots,
-	);
+	const current = await readJson<{
+		sessions?: Record<string, string>;
+		managedRoots?: string[];
+		registrationTokens?: Record<string, string>;
+	}>(fsImpl, daemonPaths(input.settings.getAgentDir()).roots);
 	const root = current?.sessions?.[input.sessionId];
-	return { root, managed: root !== undefined && current?.managedRoots?.includes(root) === true };
+	return {
+		root,
+		managed: root !== undefined && current?.managedRoots?.includes(root) === true,
+		token: current?.registrationTokens?.[input.sessionId],
+	};
 }
 
 /** Restore a session root only if this ensure operation still owns its registration. */
@@ -824,6 +1012,8 @@ async function restoreNotificationRootRegistration(input: {
 	settings: Settings;
 	sessionId: string;
 	registeredRoot: string;
+	/** Token minted by this operation's own registration; a newer replacement registration's token fences the rollback. */
+	registeredToken?: string;
 	previous: NotificationRootRegistration;
 	fs?: TelegramDaemonFs;
 }): Promise<void> {
@@ -834,14 +1024,24 @@ async function restoreNotificationRootRegistration(input: {
 		paths.roots,
 		async () => {
 			const current =
-				(await readJson<{ roots?: string[]; managedRoots?: string[]; sessions?: Record<string, string> }>(
-					fsImpl,
-					paths.roots,
-				)) ?? {};
+				(await readJson<{
+					roots?: string[];
+					managedRoots?: string[];
+					sessions?: Record<string, string>;
+					registrationTokens?: Record<string, string>;
+				}>(fsImpl, paths.roots)) ?? {};
 			const sessions = { ...(current.sessions ?? {}) };
 			if (sessions[input.sessionId] !== input.registeredRoot) return;
+			if (
+				current.registrationTokens?.[input.sessionId] !== undefined &&
+				current.registrationTokens[input.sessionId] !== input.registeredToken
+			)
+				return;
+			const registrationTokens = { ...(current.registrationTokens ?? {}) };
 			if (input.previous.root) sessions[input.sessionId] = input.previous.root;
 			else delete sessions[input.sessionId];
+			if (input.previous.token !== undefined) registrationTokens[input.sessionId] = input.previous.token;
+			else delete registrationTokens[input.sessionId];
 			const referencedRoots = new Set(Object.values(sessions));
 			const roots = new Set(current.roots ?? []);
 			const managedRoots = new Set(current.managedRoots ?? []);
@@ -859,33 +1059,44 @@ async function restoreNotificationRootRegistration(input: {
 				roots: Array.from(roots).sort(),
 				managedRoots: Array.from(managedRoots).sort(),
 				sessions,
+				registrationTokens,
 			});
 		},
 		{ staleMs: 10_000 },
 	);
 }
 
+export interface RegisterNotificationRootResult {
+	root: string;
+	/** Per-registration ownership token fencing a stale same-session cleanup from deleting a live replacement registration. */
+	token: string;
+}
+
 export async function registerNotificationRoot(input: {
 	settings: Settings;
 	cwd: string;
 	sessionId: string;
 	fs?: TelegramDaemonFs;
-}): Promise<string> {
+}): Promise<RegisterNotificationRootResult> {
 	const fsImpl = input.fs ?? nodeFs;
 	const paths = daemonPaths(input.settings.getAgentDir());
 	await ensureDir(fsImpl, paths.dir);
 	const root = notificationRootForCwd(input.cwd);
+	const token = crypto.randomUUID();
 	await withFileLock(
 		paths.roots,
 		async () => {
 			const current =
-				(await readJson<{ roots?: string[]; managedRoots?: string[]; sessions?: Record<string, string> }>(
-					fsImpl,
-					paths.roots,
-				)) ?? {};
+				(await readJson<{
+					roots?: string[];
+					managedRoots?: string[];
+					sessions?: Record<string, string>;
+					registrationTokens?: Record<string, string>;
+				}>(fsImpl, paths.roots)) ?? {};
 			const roots = new Set(current.roots ?? []);
 			const managedRoots = new Set(current.managedRoots ?? []);
 			const sessions = { ...(current.sessions ?? {}) };
+			const registrationTokens = { ...(current.registrationTokens ?? {}) };
 			const previousRoot = sessions[input.sessionId];
 			const rootAlreadyPresent = roots.has(root);
 			roots.add(root);
@@ -893,6 +1104,7 @@ export async function registerNotificationRoot(input: {
 			// survive a later session rollback or unregister.
 			if (!rootAlreadyPresent) managedRoots.add(root);
 			sessions[input.sessionId] = root;
+			registrationTokens[input.sessionId] = token;
 			if (previousRoot && previousRoot !== root && managedRoots.has(previousRoot)) {
 				const previousStillReferenced = Object.values(sessions).includes(previousRoot);
 				if (!previousStillReferenced) {
@@ -905,16 +1117,19 @@ export async function registerNotificationRoot(input: {
 				roots: Array.from(roots).sort(),
 				managedRoots: Array.from(managedRoots).sort(),
 				sessions,
+				registrationTokens,
 			});
 		},
-		{ staleMs: 10_000 },
+		ROOTS_REGISTRATION_LOCK_OPTIONS,
 	);
-	return root;
+	return { root, token };
 }
 
 export interface UnregisterNotificationRootResult {
 	root: string;
 	remainingRoots: number;
+	/** Opaque fingerprint of the exact registry written by this successful unregister. */
+	registryFingerprint?: string;
 }
 
 /** Remove one session's Telegram scan root without disturbing other live session roots. */
@@ -923,20 +1138,19 @@ export async function unregisterNotificationRoot(input: {
 	cwd: string;
 	sessionId: string;
 	fs?: TelegramDaemonFs;
+	/** Ownership token minted by this runtime's own registration; a stale cleanup presenting an older token never deletes a replacement registration. */
+	registrationToken?: string;
 }): Promise<UnregisterNotificationRootResult> {
 	const fsImpl = input.fs ?? nodeFs;
 	const paths = daemonPaths(input.settings.getAgentDir());
 	const root = notificationRootForCwd(input.cwd);
 	await ensureDir(fsImpl, paths.dir);
 	let remainingRoots = 0;
+	let registryFingerprint: string | undefined;
 	await withFileLock(
 		paths.roots,
 		async () => {
-			const current = await readJson<{
-				roots?: string[];
-				managedRoots?: string[];
-				sessions?: Record<string, string>;
-			}>(fsImpl, paths.roots);
+			const current = await readJson<NotificationRootsRegistry>(fsImpl, paths.roots);
 			if (!current) return;
 			const sessions = { ...(current.sessions ?? {}) };
 			// A stale cleanup from a previous registration must not remove a newer
@@ -945,7 +1159,19 @@ export async function unregisterNotificationRoot(input: {
 				remainingRoots = (current.roots ?? []).length;
 				return;
 			}
+			// Same sessionId + same cwd re-registration records an identical root, so
+			// the root match alone cannot distinguish a replaced registration. Any
+			// token-bearing registration requires the caller to present that exact token;
+			// only genuinely legacy token-less rows retain root-match cleanup behavior.
+			const recordedToken = current.registrationTokens?.[input.sessionId];
+			if (recordedToken !== undefined && recordedToken !== input.registrationToken) {
+				logger.warn("notifications: fenced stale Telegram root unregister against a live replacement registration");
+				remainingRoots = (current.roots ?? []).length;
+				return;
+			}
 			delete sessions[input.sessionId];
+			const registrationTokens = { ...(current.registrationTokens ?? {}) };
+			delete registrationTokens[input.sessionId];
 			const rootStillReferenced = Object.values(sessions).includes(root);
 			const managedRoots = new Set(current.managedRoots ?? []);
 			const roots = (current.roots ?? []).filter(
@@ -953,16 +1179,46 @@ export async function unregisterNotificationRoot(input: {
 			);
 			if (!rootStillReferenced) managedRoots.delete(root);
 			remainingRoots = roots.length;
-			await writeJsonAtomic(fsImpl, paths.roots, {
+			const nextRegistry: NotificationRootsRegistry = {
 				version: 1,
 				roots: Array.from(new Set(roots)).sort(),
 				managedRoots: Array.from(managedRoots).sort(),
 				sessions,
-			});
+				registrationTokens,
+			};
+			await writeJsonAtomic(fsImpl, paths.roots, nextRegistry);
+			registryFingerprint = notificationRootRegistryFingerprint(nextRegistry);
+		},
+		{ staleMs: 10_000 },
+	);
+	return registryFingerprint === undefined ? { root, remainingRoots } : { root, remainingRoots, registryFingerprint };
+}
+
+/** Run an action while the roots registry lock excludes any registration or unregister. */
+export async function withNotificationRootRegistryFence(input: {
+	settings: Settings;
+	registryFingerprint: string;
+	action: () => Promise<void>;
+	fs?: TelegramDaemonFs;
+}): Promise<boolean> {
+	const fsImpl = input.fs ?? nodeFs;
+	const paths = daemonPaths(input.settings.getAgentDir());
+	await ensureDir(fsImpl, paths.dir);
+	return await withFileLock(
+		paths.roots,
+		async () => {
+			const current = await readJson<NotificationRootsRegistry>(fsImpl, paths.roots);
+			if (
+				!current ||
+				(current.roots ?? []).length !== 0 ||
+				notificationRootRegistryFingerprint(current) !== input.registryFingerprint
+			)
+				return false;
+			await input.action();
+			return true;
 		},
 		{ staleMs: 10_000 },
 	);
-	return { root, remainingRoots };
 }
 
 function notificationRootForCwd(cwd: string): string {
@@ -998,8 +1254,32 @@ type NotificationRootsRegistry = {
 	roots?: string[];
 	managedRoots?: string[];
 	sessions?: Record<string, string>;
+	registrationTokens?: Record<string, string>;
 };
 
+function notificationRootRegistryFingerprint(registry: NotificationRootsRegistry): string {
+	return crypto
+		.createHash("sha256")
+		.update(
+			JSON.stringify({
+				version: registry.version,
+				roots: Array.from(new Set(registry.roots ?? [])).sort(),
+				managedRoots: Array.from(new Set(registry.managedRoots ?? [])).sort(),
+				sessions: Object.fromEntries(
+					Object.entries(registry.sessions ?? {}).sort(([left], [right]) =>
+						left < right ? -1 : left > right ? 1 : 0,
+					),
+				),
+				registrationTokens: Object.fromEntries(
+					Object.entries(registry.registrationTokens ?? {}).sort(([left], [right]) =>
+						left < right ? -1 : left > right ? 1 : 0,
+					),
+				),
+			}),
+		)
+		.digest("hex");
+}
+
 /**
  * Drop permanently missing scan roots from the durable registry under the roots
  * lock. Session map entries that pointed only at those roots are removed too.
@@ -1022,6 +1302,7 @@ export async function pruneMissingNotificationRoots(input: {
 			const roots = [...(current.roots ?? [])];
 			const managedRoots = new Set(current.managedRoots ?? []);
 			const sessions = { ...(current.sessions ?? {}) };
+			const registrationTokens = { ...(current.registrationTokens ?? {}) };
 			const candidateSet = input.candidates ? new Set(input.candidates) : undefined;
 			const survivors: string[] = [];
 			for (const root of roots) {
@@ -1052,7 +1333,10 @@ export async function pruneMissingNotificationRoots(input: {
 					pruned.push(root);
 					managedRoots.delete(root);
 					for (const [sessionId, mapped] of Object.entries(sessions)) {
-						if (mapped === root) delete sessions[sessionId];
+						if (mapped === root) {
+							delete sessions[sessionId];
+							delete registrationTokens[sessionId];
+						}
 					}
 				}
 			}
@@ -1063,6 +1347,7 @@ export async function pruneMissingNotificationRoots(input: {
 				roots: Array.from(new Set(survivors)).sort(),
 				managedRoots: Array.from(managedRoots).sort(),
 				sessions,
+				registrationTokens,
 			});
 		},
 		{ staleMs: 10_000 },
@@ -1220,7 +1505,9 @@ export function hasSafeDaemonStateShape(state: unknown): state is DaemonState {
 			candidate.version === DAEMON_VERSION &&
 			(candidate.generation === undefined ||
 				(Number.isSafeInteger(candidate.generation) && (candidate.generation as number) > 0)) &&
-			(candidate.stoppedAt === undefined || Number.isSafeInteger(candidate.stoppedAt)),
+			(candidate.stoppedAt === undefined || Number.isSafeInteger(candidate.stoppedAt)) &&
+			(candidate.servingEpoch === undefined ||
+				(Number.isSafeInteger(candidate.servingEpoch) && (candidate.servingEpoch as number) > 0)),
 	);
 }
 
@@ -1421,6 +1708,7 @@ async function legacyParentHandoffDecision(input: {
 > {
 	const { state } = input;
 	if (!input.pidAlive(state.pid)) return undefined;
+	if (state.generation !== 3) return { acquired: false, attached: false, blocked: true };
 	if (!ownerIdentityMatches(state, input.tokenFingerprint, input.chatId))
 		return { acquired: false, attached: false, blocked: true };
 	const incarnation = input.pidIncarnation(state.pid);
@@ -1522,12 +1810,7 @@ function isRecognizedLegacyGeneration(generation: number | undefined): boolean {
 	return generation === undefined || generation === 3;
 }
 
-/**
- * A predecessor is reloadable only when it has the complete modern ownership
- * proof. Generation is absent from the first fully-provenanced modern records,
- * so it is an incompatible predecessor too; parent-format records remain
- * excluded because they lack this ownership proof.
- */
+/** True when a modern owner carries complete ready-state provenance. */
 function hasFullModernOwnerProvenance(
 	state: DaemonState | undefined,
 	pidIncarnation?: (pid: number) => string | undefined,
@@ -1542,19 +1825,6 @@ function hasFullModernOwnerProvenance(
 	);
 }
 
-function isFullModernPredecessor(
-	state: DaemonState | undefined,
-	pidIncarnation?: (pid: number) => string | undefined,
-): boolean {
-	return Boolean(
-		hasFullModernOwnerProvenance(state, pidIncarnation) &&
-			(state?.generation === undefined ||
-				(Number.isSafeInteger(state?.generation) &&
-					(state?.generation as number) > 0 &&
-					(state?.generation as number) < DAEMON_GENERATION)),
-	);
-}
-
 /**
  * Classifies a physically live daemon record before any replacement action.
  *
@@ -1628,14 +1898,17 @@ export function isFreshLiveOwner(input: {
 	chatId: string;
 	pidAlive: (pid: number) => boolean;
 	pidIncarnation?: (pid: number) => string | undefined;
+	effectiveHeartbeatAt?: number;
 }): boolean {
 	const { state } = input;
+	const heartbeatAt = Object.hasOwn(input, "effectiveHeartbeatAt") ? input.effectiveHeartbeatAt : state?.heartbeatAt;
 	return Boolean(
 		state &&
+			heartbeatAt !== undefined &&
 			hasSafeDaemonStateShape(state) &&
 			state.stoppedAt === undefined &&
 			ownerIdentityMatches(state, input.tokenFingerprint, input.chatId) &&
-			input.now - state.heartbeatAt <= HEARTBEAT_TTL_MS &&
+			input.now - heartbeatAt <= HEARTBEAT_TTL_MS &&
 			input.pidAlive(state.pid) &&
 			ownerProvenanceMatches(state, input.pidIncarnation),
 	);
@@ -1649,6 +1922,7 @@ export function isCurrentCompatibleOwner(input: {
 	chatId: string;
 	pidAlive: (pid: number) => boolean;
 	pidIncarnation?: (pid: number) => string | undefined;
+	effectiveHeartbeatAt?: number;
 }): boolean {
 	const state = input.state;
 	return Boolean(
@@ -1656,8 +1930,7 @@ export function isCurrentCompatibleOwner(input: {
 			state?.ownershipPhase === "ready" &&
 			typeof state.acquisitionId === "string" &&
 			state.acquisitionId.length > 0 &&
-			Number.isSafeInteger(state.generation) &&
-			(state.generation as number) >= DAEMON_GENERATION,
+			(state.servingEpoch === undefined ? 1 : state.servingEpoch) >= SERVING_EPOCH,
 	);
 }
 
@@ -1701,14 +1974,14 @@ export async function acquireDaemonOwnership(input: {
 		input.ownerId ?? input.randomId?.() ?? `${pid}-${now().toString(36)}-${Math.random().toString(36).slice(2)}`;
 	const roots = input.roots ?? (await readJson<{ roots?: string[] }>(fsImpl, paths.roots))?.roots ?? [];
 
-	// A fresh, identity-matching live owner running an OLDER generation than this
-	// build cannot serve our newer wire frames; signal a reload instead of a
-	// silent attach. Newer/equal generations attach as before (no downgrade).
+	// Generation is inventory-only: a lower servingEpoch triggers convergence,
+	// while same-epoch cross-generation owners attach.
 	const attachDecision = (
-		state: DaemonState | undefined,
+		snapshot: OwnerFreshnessSnapshot,
 	):
 		| { acquired: false; attached: boolean; blocked?: boolean; provisional?: boolean; reloadRequired?: boolean }
 		| undefined => {
+		const state = snapshot.state;
 		if (state && !hasSafeDaemonStateShape(state)) {
 			const malformed = state as Partial<DaemonState>;
 			if (
@@ -1741,6 +2014,7 @@ export async function acquireDaemonOwnership(input: {
 				chatId: input.chatId,
 				pidAlive,
 				pidIncarnation,
+				effectiveHeartbeatAt: snapshot.effectiveHeartbeatAt,
 			})
 		)
 			return { acquired: false, attached: true };
@@ -1755,8 +2029,17 @@ export async function acquireDaemonOwnership(input: {
 				chatId: input.chatId,
 				pidAlive,
 				pidIncarnation,
+				effectiveHeartbeatAt: snapshot.effectiveHeartbeatAt,
 			}) &&
-			(state.version !== DAEMON_VERSION || isFullModernPredecessor(state, pidIncarnation))
+			(state.version !== DAEMON_VERSION ||
+				((state.servingEpoch === undefined ? 1 : state.servingEpoch) < SERVING_EPOCH &&
+					isSignalableMatchingOwner({
+						state,
+						tokenFingerprint: input.tokenFingerprint,
+						chatId: input.chatId,
+						pidAlive,
+						pidIncarnation,
+					})))
 		)
 			return { acquired: false, attached: false, reloadRequired: true };
 		return { acquired: false, attached: false, provisional: true };
@@ -1800,7 +2083,8 @@ export async function acquireDaemonOwnership(input: {
 	const transition = await acquireTransitionLock({ fs: fsImpl, path: paths.steal, pidAlive, pidIncarnation });
 	if (!transition) return { acquired: false, attached: false, provisional: true };
 	try {
-		const rechecked = await readJson<DaemonState>(fsImpl, paths.state);
+		const recheckedSnapshot = await readOwnerFreshnessSnapshot({ settings: input.settings, fs: fsImpl });
+		const rechecked = recheckedSnapshot.state;
 		const recheckedLock = await readOwnershipLock(fsImpl, paths.lock);
 		const recheckedForeignOwner = classifyForeignLiveOwner({
 			state: rechecked,
@@ -1826,7 +2110,7 @@ export async function acquireDaemonOwnership(input: {
 			})
 		)
 			return { acquired: false, attached: false, blocked: true };
-		const recheckedDecision = isLegacyParentDaemonState(rechecked) ? undefined : attachDecision(rechecked);
+		const recheckedDecision = isLegacyParentDaemonState(rechecked) ? undefined : attachDecision(recheckedSnapshot);
 		if (
 			recheckedDecision &&
 			(recheckedDecision.attached ||
@@ -1923,6 +2207,7 @@ export async function acquireDaemonOwnership(input: {
 			roots,
 			version: DAEMON_VERSION,
 			generation: DAEMON_GENERATION,
+			servingEpoch: SERVING_EPOCH,
 		} satisfies DaemonState);
 		if (
 			!(await transitionLockIsHeldByCaller({ fs: fsImpl, path: paths.steal, lock: transition })) ||
@@ -2022,17 +2307,20 @@ export async function renewDaemonHeartbeat(input: {
 				})))
 		)
 			return false;
+		const heartbeatAt = (input.now ?? Date.now)();
+		const boundState: DaemonState = {
+			...state,
+			// Preserve the source launcher PID so concurrent ensures can recognize
+			// this bound child as its successor while it is still provisional.
+			launcherPid: state.pid,
+			pid,
+			incarnation,
+			ownershipPhase: "provisional",
+			heartbeatAt,
+			servingEpoch: SERVING_EPOCH,
+		};
 		try {
-			await writeJsonAtomic(fsImpl, paths.state, {
-				...state,
-				// Preserve the source launcher PID so concurrent ensures can recognize
-				// this ready PID as its child rather than excluding it as the launcher.
-				launcherPid: state.pid,
-				pid,
-				incarnation,
-				ownershipPhase: "ready",
-				heartbeatAt: (input.now ?? Date.now)(),
-			});
+			await writeJsonAtomic(fsImpl, paths.state, boundState);
 		} catch {
 			if (expectedLock && reboundLock)
 				await rollbackOwnershipLockRebind({
@@ -2046,7 +2334,49 @@ export async function renewDaemonHeartbeat(input: {
 				});
 			return false;
 		}
-		return true;
+		const retireBoundOwnership = async (): Promise<void> => {
+			const lock = await readOwnershipLock(fsImpl, paths.lock);
+			if (!ownershipLockMatchesState(lock, boundState)) return;
+			await writeJsonAtomic(fsImpl, paths.state, {
+				...boundState,
+				ownershipPhase: "retired",
+				stoppedAt: (input.now ?? Date.now)(),
+			}).catch(() => undefined);
+			if (await transitionLockIsHeldByCaller({ fs: fsImpl, path: paths.steal, lock: transition }))
+				await unlinkOwnershipLockExactly(fsImpl, paths.lock, lock);
+		};
+		// The durable sidecar must exist and match the rebound ownership lock before
+		// any observer can see ownershipPhase:"ready". A provisional state may be
+		// fresh, but readiness waiters categorically refuse to attach to it.
+		let sidecarRenewed = false;
+		try {
+			sidecarRenewed = await renewOwnerHeartbeatSidecar({
+				settings: input.settings,
+				ownerId: input.ownerId,
+				acquisitionId,
+				fs: fsImpl,
+				now: () => heartbeatAt,
+				pid,
+				pidIncarnation: input.pidIncarnation,
+			});
+		} catch {
+			sidecarRenewed = false;
+		}
+		if (!sidecarRenewed) {
+			logger.warn(
+				"notifications: Telegram daemon initial heartbeat sidecar proof failed; retiring provisional ownership",
+			);
+			await retireBoundOwnership();
+			return false;
+		}
+		try {
+			await writeJsonAtomic(fsImpl, paths.state, { ...boundState, ownershipPhase: "ready" });
+			return true;
+		} catch {
+			logger.warn("notifications: Telegram daemon ready publication failed after sidecar proof; retiring ownership");
+			await retireBoundOwnership();
+			return false;
+		}
 	} finally {
 		await releaseDaemonTransitionLock({ fs: fsImpl, path: paths.steal, lock: transition });
 	}
@@ -2225,7 +2555,7 @@ async function bindProvisionalDaemonPid(input: {
 	}
 }
 
-/** Wait for a matching current-generation daemon to publish a ready state. */
+/** Wait for a matching compatible owner to publish a ready state. Readiness is serving-epoch gated (same-epoch cross-generation owners attach, per isCurrentCompatibleOwner); generation is inventory-only here. Mutation paths still require exact current-generation equality. */
 export async function waitForTelegramDaemonReady(input: {
 	settings: Settings;
 	ownerId?: string;
@@ -2251,12 +2581,13 @@ export async function waitForTelegramDaemonReady(input: {
 	const deadline = now() + timeoutMs;
 	const maxPolls = Math.ceil(timeoutMs / waitStepMs);
 	for (let poll = 0; poll <= maxPolls; poll++) {
-		const state = await readDaemonState(input.settings, input.fs);
+		const snapshot = await readOwnerFreshnessSnapshot({ settings: input.settings, fs: input.fs });
+		const state = snapshot.state;
 		if (
 			(!input.ownerId || state?.ownerId === input.ownerId) &&
 			(!input.acquisitionId || state?.acquisitionId === input.acquisitionId) &&
 			state?.ownershipPhase === "ready" &&
-			state.generation === DAEMON_GENERATION &&
+			Number.isSafeInteger(state.generation) &&
 			ownerIdentityMatches(state, input.tokenFingerprint, input.chatId) &&
 			ownerProvenanceMatches(state, pidIncarnation) &&
 			pidAlive(state.pid) &&
@@ -2270,6 +2601,7 @@ export async function waitForTelegramDaemonReady(input: {
 				chatId: input.chatId,
 				pidAlive,
 				pidIncarnation,
+				effectiveHeartbeatAt: snapshot.effectiveHeartbeatAt,
 			})
 		)
 			return true;
@@ -2339,7 +2671,8 @@ export async function confirmTelegramDaemonSpawn(input: {
 		sleep: input.sleep,
 	});
 	if (retired) return false;
-	const state = await readDaemonState(input.settings, input.fs);
+	const snapshot = await readOwnerFreshnessSnapshot({ settings: input.settings, fs: input.fs });
+	const state = snapshot.state;
 	if (
 		hasExactChildPid &&
 		isCurrentCompatibleOwner({
@@ -2349,6 +2682,7 @@ export async function confirmTelegramDaemonSpawn(input: {
 			chatId: input.chatId,
 			pidAlive: input.pidAlive ?? defaultPidAlive,
 			pidIncarnation: input.pidIncarnation ?? defaultPidIncarnation,
+			effectiveHeartbeatAt: snapshot.effectiveHeartbeatAt,
 		}) &&
 		(state?.ownerId !== input.spawned.acquisition.ownerId ||
 			state.acquisitionId !== input.spawned.acquisition.acquisitionId ||
@@ -2812,8 +3146,15 @@ export async function reclaimDeadDaemonOwner(input: {
  * Ensure a configured daemon owns this session root, preserving ownership safety
  * while exposing whether a #2028 generation handoff was required.
  */
-export async function ensureTelegramDaemonRunningDetailed(
-	input: { settings: Settings; cwd: string; sessionId: string },
+async function ensureTelegramDaemonRunningDetailedOnce(
+	input: {
+		settings: Settings;
+		cwd: string;
+		sessionId: string;
+		registerRoot?: boolean;
+		/** Receives each registration this ensure operation minted so the caller can fence its own later cleanup. */
+		onRegistered?: (registration: RegisterNotificationRootResult) => void;
+	},
 	deps: TelegramDaemonDeps = {},
 ): Promise<EnsureTelegramDaemonDetailedResult> {
 	const cfg = getNotificationConfig(input.settings);
@@ -2919,7 +3260,12 @@ export async function ensureTelegramDaemonRunningDetailed(
 	}
 	if (spawned.result === "attached" && spawned.reloadRequired) {
 		const previous = await readNotificationRootRegistration({ ...input, fs: deps.fs });
-		await registerNotificationRoot({ ...input, fs: deps.fs });
+		let registeredToken: string | undefined;
+		if (input.registerRoot !== false) {
+			const registered = await registerNotificationRoot({ ...input, fs: deps.fs });
+			registeredToken = registered.token;
+			input.onRegistered?.(registered);
+		}
 		const fsImpl = deps.fs ?? nodeFs;
 		const now = deps.now ?? Date.now;
 		const pidAlive = deps.pidAlive ?? defaultPidAlive;
@@ -2958,22 +3304,28 @@ export async function ensureTelegramDaemonRunningDetailed(
 					// Iteration-capped so a frozen `now` cannot spin forever.
 					const maxWaits = Math.ceil(waitBudgetMs / waitStepMs);
 					for (let waits = 0; waits <= maxWaits; waits++) {
-						const state = await readDaemonState(input.settings, fsImpl);
+						const snapshot = await readOwnerFreshnessSnapshot({ settings: input.settings, fs: fsImpl });
+						const state = snapshot.state;
 						const t = now();
 						if (
-							isFreshLiveOwner({
+							isCurrentCompatibleOwner({
 								state,
 								now: t,
 								tokenFingerprint: fp,
 								chatId: cfg.chatId,
 								pidAlive,
 								pidIncarnation,
+								effectiveHeartbeatAt: snapshot.effectiveHeartbeatAt,
 							})
 						)
 							return "attached" as const;
 						if (t >= deadline) break;
 						await sleep(waitStepMs);
 					}
+					// Keep the reservation after a failed reload so concurrent ensures do not
+					// repeatedly signal the same incompatible predecessor. Surface the failed
+					// convergence; the next ensure after cooldown expiry retries the reload.
+					return "blocked_identity" as const;
 				}
 				await writeJsonAtomic(fsImpl, reloadAttemptPath, {
 					lastReloadAt: reloadNow,
@@ -2991,11 +3343,23 @@ export async function ensureTelegramDaemonRunningDetailed(
 			}),
 		);
 		if (reloadResult === "attached") return "attached";
+		if (reloadResult === "blocked_identity") {
+			await restoreNotificationRootRegistration({
+				settings: input.settings,
+				sessionId: input.sessionId,
+				registeredRoot: root,
+				registeredToken,
+				previous,
+				fs: deps.fs,
+			});
+			return "blocked_identity";
+		}
 		if (reloadResult !== "reloaded") {
 			await restoreNotificationRootRegistration({
 				settings: input.settings,
 				sessionId: input.sessionId,
 				registeredRoot: root,
+				registeredToken,
 				previous,
 				fs: deps.fs,
 			});
@@ -3004,7 +3368,10 @@ export async function ensureTelegramDaemonRunningDetailed(
 		return "reloaded";
 	}
 	if (spawned.result !== "owner_spawned") {
-		await registerNotificationRoot({ ...input, fs: deps.fs });
+		if (input.registerRoot !== false) {
+			const registered = await registerNotificationRoot({ ...input, fs: deps.fs });
+			input.onRegistered?.(registered);
+		}
 		return "attached";
 	}
 	if (
@@ -3023,12 +3390,54 @@ export async function ensureTelegramDaemonRunningDetailed(
 			timeoutMs: deps.readinessTimeoutMs,
 		})
 	) {
-		await registerNotificationRoot({ ...input, fs: deps.fs });
+		if (input.registerRoot !== false) {
+			const registered = await registerNotificationRoot({ ...input, fs: deps.fs });
+			input.onRegistered?.(registered);
+		}
 		return "spawned";
 	}
 	throw new Error("Telegram daemon did not become ready after spawning");
 }
 
+/**
+ * Ensure a configured daemon owns this session root, preserving ownership safety
+ * while exposing whether a #2028 generation handoff was required.
+ */
+export async function ensureTelegramDaemonRunningDetailed(
+	input: {
+		settings: Settings;
+		cwd: string;
+		sessionId: string;
+		registerRoot?: boolean;
+		/** Receives each registration this ensure operation minted so the caller can fence its own later cleanup. */
+		onRegistered?: (registration: RegisterNotificationRootResult) => void;
+	},
+	deps: TelegramDaemonDeps = {},
+): Promise<EnsureTelegramDaemonDetailedResult> {
+	const result = await ensureTelegramDaemonRunningDetailedOnce(input, deps);
+	if (input.registerRoot === false || (result !== "attached" && result !== "spawned")) return result;
+
+	const cfg = getNotificationConfig(input.settings);
+	if (!isTelegramConfigured(cfg)) return "disabled";
+	const ownerIsCurrent = async (): Promise<boolean> => {
+		const snapshot = await readOwnerFreshnessSnapshot({ settings: input.settings, fs: deps.fs });
+		return isCurrentCompatibleOwner({
+			state: snapshot.state,
+			now: (deps.now ?? Date.now)(),
+			tokenFingerprint: tokenFingerprint(cfg.botToken),
+			chatId: cfg.chatId,
+			pidAlive: deps.pidAlive ?? defaultPidAlive,
+			pidIncarnation: deps.pidIncarnation ?? defaultPidIncarnation,
+			effectiveHeartbeatAt: snapshot.effectiveHeartbeatAt,
+		});
+	};
+	if (await ownerIsCurrent()) return result;
+
+	const converged = await ensureTelegramDaemonRunningDetailedOnce({ ...input, registerRoot: false }, deps);
+	if (converged === "disabled" || converged === "blocked_identity") return converged;
+	return (await ownerIsCurrent()) ? converged : "blocked_identity";
+}
+
 /**
  * Legacy compatibility mapping for callers that only distinguish ownership from
  * attachment. New orchestration should use {@link ensureTelegramDaemonRunningDetailed}.
@@ -3196,7 +3605,7 @@ export type TelegramPollResult =
 export interface TelegramUpdatePollerOptions {
 	botApi: BotApi;
 	runtime: NotificationOperatorRuntime;
-	backoff: OperatorBackoffPolicy;
+	backoff: { next(): number; reset(): void };
 	processUpdate: (update: unknown) => Promise<TelegramUpdateOutcome>;
 	health?: TelegramPollHealth;
 }
@@ -3258,6 +3667,20 @@ export class TelegramPollHealth {
 	}
 }
 
+class JitteredPollConflictBackoff {
+	#currentMs = 0;
+
+	next(): number {
+		if (this.#currentMs === 0) this.#currentMs = POLL_BACKOFF_MS;
+		else this.#currentMs = Math.min(this.#currentMs * (1.5 + Math.random() * 0.5), 10_000);
+		return this.#currentMs;
+	}
+
+	reset(): void {
+		this.#currentMs = 0;
+	}
+}
+
 /** Owns getUpdates offset, conflict backoff, and per-update error isolation. */
 export class TelegramUpdatePoller {
 	#offset = 0;
@@ -3423,7 +3846,7 @@ export interface TelegramDaemonOptions {
 	rich?: { enabled: boolean };
 	/** Opt-in rich-draft streaming of live turn previews (off by default; see rich-draft.ts). */
 	richDraft?: { enabled: boolean };
-	/** Tool start/completion messages (enabled by default). */
+	/** Tool start/completion messages (off by default; explicit opt-in only). */
 	toolActivity?: { enabled: boolean };
 	/**
 	 * Per-session Telegram forum-topic naming. `nameTemplate` supports the
@@ -3452,6 +3875,8 @@ interface SessionSocket {
 	/** True once the server advertised the `client_ping_pong` capability. */
 	capable: boolean;
 	ephemeralCapable: boolean;
+	/** Tool activity contract advertised by the connected host. */
+	toolActivityCapability?: "v1" | "v2";
 	/** Timestamp (via opts.now) of the last received pong; seeds the TTL window. */
 	lastPongAt: number;
 	/** Nonce of the most recent in-flight ping, if any. */
@@ -3502,6 +3927,19 @@ interface ToolActivityOwner {
 	session: SessionSocket;
 	phase: "started" | "terminal";
 	policyEpoch?: number;
+	summaryFreeSend?: ThreadedSend;
+}
+type LegacyToolStartOutcome = "visible" | "failed" | "cancelled" | "terminal";
+interface LegacyToolStartSettlement {
+	key: string;
+	owner: ToolActivityOwner;
+	policyEpoch: number;
+	phase: "admitted" | "pending_identity" | "queued" | "dispatching" | LegacyToolStartOutcome;
+	itemId?: string;
+	settled: Promise<LegacyToolStartOutcome>;
+	resolve: (outcome: LegacyToolStartOutcome) => void;
+	settledOutcome?: LegacyToolStartOutcome;
+	terminalClaimed?: boolean;
 }
 
 interface PendingThreadedFrame {
@@ -3518,6 +3956,35 @@ type SelectedAckOutcome =
 	| { status: "unknown"; reason: "transport_ambiguous" | "shutdown" };
 type BtwQueuedDeliveryOutcome = "accepted" | "not_delivered" | "uncertain" | "stale" | "partial_accepted";
 
+type BotApiCallOutcome =
+	| { kind: "accepted" }
+	| { kind: "rejected" }
+	| { kind: "retryable"; retryAfterMs: number }
+	| { kind: "unknown" };
+
+interface BotApiCallResult {
+	response: unknown;
+	outcome: BotApiCallOutcome;
+}
+
+function classifyBotApiCallOutcome(response: unknown, cooldownSuppressed = false): BotApiCallOutcome {
+	if (cooldownSuppressed) return { kind: "retryable", retryAfterMs: 0 };
+	if (!response || typeof response !== "object") return { kind: "unknown" };
+	const body = response as {
+		ok?: unknown;
+		error_code?: unknown;
+		parameters?: { retry_after?: unknown };
+	};
+	if (body.ok === false && body.error_code === 429) {
+		const retryAfter = body.parameters?.retry_after;
+		const seconds = typeof retryAfter === "number" && Number.isFinite(retryAfter) ? retryAfter : 30;
+		return { kind: "retryable", retryAfterMs: Math.min(3600, Math.max(1, seconds)) * 1_000 };
+	}
+	if (body.ok === true) return { kind: "accepted" };
+	if (body.ok === false) return { kind: "rejected" };
+	return { kind: "unknown" };
+}
+
 interface BtwQueuedDelivery {
 	pending: PendingBtwTurn;
 	body: Record<string, unknown>;
@@ -3548,6 +4015,8 @@ interface TelegramQueuePayload {
 	selectedAck?: SelectedAckQueueItem;
 	btwDelivery?: BtwQueuedDelivery;
 	toolActivity?: ToolActivityOwner;
+	/** Exact admitted legacy-v1 start authorized for this terminal delivery. */
+	legacyToolStart?: LegacyToolStartSettlement;
 }
 
 interface PendingBtwTurn {
@@ -3645,6 +4114,9 @@ export class TelegramNotificationDaemon {
 	/** Endpoint-bound ownership for visible or dispatching tool bubbles. */
 	private readonly toolActivityOwners = new Map<string, ToolActivityOwner>();
 	private readonly revokedToolEndpoints = new Set<string>();
+	/** Exact settlement of each admitted legacy-v1 start; retained only while visible. */
+	private readonly legacyToolStarts = new Map<string, LegacyToolStartSettlement>();
+	private nextLegacyToolStartId = 1;
 	private readonly unresolvedToolTerminalizations = new Map<string, { messageId: number; owner: ToolActivityOwner }>();
 	private toolTerminalizationChain: Promise<void> = Promise.resolve();
 	private toolActivityPolicyEpoch = 0;
@@ -3658,7 +4130,7 @@ export class TelegramNotificationDaemon {
 
 	private readonly runtime: NotificationOperatorRuntime;
 	private readonly sessionRouter: OperatorEventRouter<SessionSocket>;
-	private readonly pollConflictBackoff = new OperatorBackoffPolicy({ initialMs: 500, maxMs: 5_000 });
+	private readonly pollConflictBackoff = new JitteredPollConflictBackoff();
 	private readonly loopBackoff = new OperatorBackoffPolicy({ initialMs: 250, maxMs: 4_000 });
 	private running = false;
 	/** Once set, a concurrent startup await can never restore a running daemon. */
@@ -3698,6 +4170,9 @@ export class TelegramNotificationDaemon {
 	private readonly pool: RateLimitPool<TelegramQueuePayload>;
 	private readonly poller: TelegramUpdatePoller;
 	private readonly dispatchState = new TelegramEventDispatchState();
+	/** Bot-wide flood-control window; inbound polling remains eligible during it. */
+	private botCooldownUntil = 0;
+	private warnedBotCooldownUntil = 0;
 	/** Original markdown of rich messages we sent (chat+message_id), for restoring reply context on inbound replies. */
 	private readonly replyStore: ReplySentStore;
 	/** Per-session debounce + monotonic draft-id state for opt-in draft streaming. */
@@ -4116,8 +4591,8 @@ export class TelegramNotificationDaemon {
 
 	private async refreshBotIdentity(): Promise<void> {
 		try {
-			const response = (await this.botApi.call("getMe", {})) as { result?: { username?: unknown } };
-			const username = response.result?.username;
+			const response = (await this.botApi.call("getMe", {})) as { result?: { username?: unknown } } | undefined;
+			const username = response?.result?.username;
 			this.botUsername =
 				typeof username === "string" && username.trim() ? username.trim().replace(/^@/, "") : undefined;
 		} catch {
@@ -4130,6 +4605,47 @@ export class TelegramNotificationDaemon {
 		return formatLifecycleOutcome(r, verb);
 	}
 
+	private async callBotApi(
+		rawBotApi: BotApi,
+		method: string,
+		body: unknown,
+		callOpts?: { signal?: AbortSignal; noRetry?: boolean },
+	): Promise<BotApiCallResult> {
+		const now = this.opts.now?.() ?? Date.now();
+		if (method !== "getUpdates" && now < this.botCooldownUntil) {
+			if (this.warnedBotCooldownUntil !== this.botCooldownUntil) {
+				this.warnedBotCooldownUntil = this.botCooldownUntil;
+				logger.warn("notifications: Telegram Bot API flood-control cooldown suppressing outbound calls");
+			}
+			const outcome = classifyBotApiCallOutcome(undefined, true);
+			return { response: undefined, outcome };
+		}
+		const response = await this.effects.call(rawBotApi, method, body, callOpts);
+		const outcome = classifyBotApiCallOutcome(response);
+		if (outcome.kind === "retryable")
+			this.botCooldownUntil = Math.max(
+				this.botCooldownUntil,
+				(this.opts.now?.() ?? Date.now()) + outcome.retryAfterMs,
+			);
+		return { response, outcome };
+	}
+
+	private readonly callBotApiClassified: (
+		method: string,
+		body: unknown,
+		callOpts?: { signal?: AbortSignal; noRetry?: boolean },
+	) => Promise<BotApiCallResult>;
+
+	private botApiWithOutcomeCollector(outcomes: BotApiCallOutcome[]): BotApi {
+		return {
+			call: async (method, body, callOpts) => {
+				const result = await this.callBotApiClassified(method, body, callOpts);
+				outcomes.push(result.outcome);
+				return result.response;
+			},
+		};
+	}
+
 	constructor(private readonly opts: TelegramDaemonOptions) {
 		this.fsImpl = opts.fs ?? nodeFs;
 		this.replyStore = new ReplySentStore({ agentDir: opts.settings.getAgentDir(), fs: opts.fs });
@@ -4142,8 +4658,9 @@ export class TelegramNotificationDaemon {
 				fetchImpl: opts.fetchImpl,
 				setTimeoutImpl: opts.setTimeoutImpl,
 			});
+		this.callBotApiClassified = (method, body, callOpts) => this.callBotApi(rawBotApi, method, body, callOpts);
 		this.botApi = {
-			call: (method, body, callOpts) => this.effects.call(rawBotApi, method, body, callOpts),
+			call: async (method, body, callOpts) => (await this.callBotApiClassified(method, body, callOpts)).response,
 		};
 		this.runtime = new NotificationOperatorRuntime({
 			now: opts.now,
@@ -4169,6 +4686,10 @@ export class TelegramNotificationDaemon {
 				matches: msg => msg.type === "hello",
 				handle: (session, msg) => {
 					const caps = Array.isArray(msg.capabilities) ? msg.capabilities : [];
+					const previousToolActivityCapability = session.toolActivityCapability;
+					session.toolActivityCapability = negotiateToolActivityCapability(previousToolActivityCapability, caps);
+					if (previousToolActivityCapability === "v1" && session.toolActivityCapability === "v2")
+						this.cleanLegacyToolStartsForCapabilityUpgrade(session);
 					if (caps.includes("ephemeral_turn_v1")) session.ephemeralCapable = true;
 					if (caps.includes(CLIENT_PING_PONG_CAPABILITY)) {
 						session.capable = true;
@@ -4701,6 +5222,7 @@ export class TelegramNotificationDaemon {
 								ASK_CONTROLS_CAPABILITY,
 								ASK_SELECTED_ACK_CAPABILITY,
 								TOOL_ACTIVITY_CAPABILITY,
+								LEGACY_TOOL_ACTIVITY_CAPABILITY,
 								"ephemeral_turn_v1",
 							],
 						}),
@@ -4794,12 +5316,12 @@ export class TelegramNotificationDaemon {
 				for (const item of claimedItems) {
 					const { messageId, owner } = item;
 					const backlogKey = `${owner.endpointDigest}\0${owner.sessionId}\0${owner.toolCallId}\0${messageId}`;
-					const send = renderThreadedFrame({
+					const send = this.renderThreadedFrame({
 						type: "tool_activity",
 						sessionId: owner.sessionId,
 						toolCallId: owner.toolCallId,
 						toolName: owner.toolName,
-						phase: "unknown",
+						phase: "cancelled",
 					});
 					if (!send?.text) continue;
 					let failure: unknown;
@@ -4857,6 +5379,9 @@ export class TelegramNotificationDaemon {
 				this.toolActivityOwners.delete(key);
 				const messageId = this.liveMessages.get(key);
 				this.liveMessages.delete(key);
+				const legacyStart = this.legacyToolStarts.get(key);
+				if (legacyStart !== undefined && legacyStart.owner === owner)
+					this.settleLegacyToolStart(legacyStart, "terminal");
 				if (messageId !== undefined) {
 					const backlogKey = `${owner.endpointDigest}\0${owner.sessionId}\0${owner.toolCallId}\0${messageId}`;
 					claimedByKey.set(backlogKey, { messageId, owner });
@@ -4884,6 +5409,7 @@ export class TelegramNotificationDaemon {
 		this.toolActivityStopping = true;
 		this.toolActivityPolicyEpoch++;
 		this.toolShutdownBarrier = (async () => {
+			await this.cancelLegacyToolStartsForPolicyTransition();
 			await this.flushChain;
 			const failures: Error[] = [];
 			if (this.toolActivityAmbiguous) {
@@ -4908,6 +5434,7 @@ export class TelegramNotificationDaemon {
 		if (session.recoveryLease) session.recoveryLease = { ...session.recoveryLease, state: "rejected" };
 		const isCurrentSession = this.sessions.get(session.sessionId) === session;
 		if (isCurrentSession) this.droppedSessions.add(session);
+		if (isCurrentSession) this.cancelLegacyToolStartsForSession(session);
 		if (isCurrentSession) this.scheduleVisibleToolTerminalization(session.endpointDigest).catch(() => undefined);
 		const clearIntervalImpl = this.opts.clearIntervalImpl ?? clearInterval;
 		if (session.pingTimer) {
@@ -5438,7 +5965,7 @@ export class TelegramNotificationDaemon {
 			typeof msg.sessionId !== "string" ||
 			!msg.sessionId.trim() ||
 			msg.sessionId === this.#logicalSessionId(session) ||
-			(msg.type !== "config_update" && !renderThreadedFrame(msg))
+			(msg.type !== "config_update" && !this.renderThreadedFrame(msg))
 		)
 			return;
 		if (!session.logicalSessionIdTrusted) return;
@@ -5700,12 +6227,151 @@ export class TelegramNotificationDaemon {
 		return undefined;
 	}
 
+	private admitLegacyToolStart(owner: ToolActivityOwner): LegacyToolStartSettlement | undefined {
+		if (owner.session.toolActivityCapability !== "v1") return undefined;
+		const key = `${owner.sessionId}:tool:${owner.toolCallId}`;
+		if (this.legacyToolStarts.has(key)) return undefined;
+		const deferred = Promise.withResolvers<LegacyToolStartOutcome>();
+		const state: LegacyToolStartSettlement = {
+			key,
+			owner,
+			policyEpoch: owner.policyEpoch ?? this.toolActivityPolicyEpoch,
+			phase: "admitted",
+			settled: deferred.promise,
+			resolve: deferred.resolve,
+		};
+		this.legacyToolStarts.set(key, state);
+		return state;
+	}
+	private legacyToolStartForTerminal(owner: ToolActivityOwner): LegacyToolStartSettlement | undefined {
+		if (owner.phase !== "terminal") return undefined;
+		const key = `${owner.sessionId}:tool:${owner.toolCallId}`;
+		const state = this.legacyToolStarts.get(key);
+		if (
+			state === undefined ||
+			state.key !== key ||
+			state.owner.session !== owner.session ||
+			state.owner.endpointDigest !== owner.endpointDigest ||
+			state.owner.toolName !== owner.toolName ||
+			state.policyEpoch !== owner.policyEpoch
+		)
+			return undefined;
+		return state;
+	}
+
+	private settleLegacyToolStart(state: LegacyToolStartSettlement, outcome: LegacyToolStartOutcome): void {
+		if (state.settledOutcome === undefined) {
+			state.settledOutcome = outcome;
+			state.resolve(outcome);
+		}
+		state.phase = outcome;
+		if (outcome !== "visible" && this.legacyToolStarts.get(state.key) === state)
+			this.legacyToolStarts.delete(state.key);
+		if (outcome !== "visible" && !this.liveMessages.has(state.key)) {
+			const owner = this.toolActivityOwners.get(state.key);
+			if (owner === state.owner) this.toolActivityOwners.delete(state.key);
+		}
+	}
+
+	private cancelUnsentLegacyToolStart(state: LegacyToolStartSettlement): boolean {
+		if (state.phase !== "admitted" && state.phase !== "pending_identity" && state.phase !== "queued") return false;
+		if (state.itemId) this.pool.removeById(state.itemId);
+		for (const [sessionId, frames] of this.pendingThreadedFrames) {
+			const retained = frames.filter(frame => frame.toolActivity !== state.owner);
+			if (retained.length === 0) this.pendingThreadedFrames.delete(sessionId);
+			else if (retained.length !== frames.length) this.pendingThreadedFrames.set(sessionId, retained);
+		}
+		this.settleLegacyToolStart(state, "cancelled");
+		return true;
+	}
+
+	private failLegacyToolStart(toolActivity: ToolActivityOwner | undefined): void {
+		if (toolActivity?.phase !== "started") return;
+		const state = this.legacyToolStarts.get(`${toolActivity.sessionId}:tool:${toolActivity.toolCallId}`);
+		if (state !== undefined && state.owner === toolActivity && state.phase !== "visible")
+			this.settleLegacyToolStart(state, "failed");
+	}
+
+	private settleRejectedLegacyToolSubmission(
+		toolActivity: ToolActivityOwner | undefined,
+		legacyToolStart: LegacyToolStartSettlement | undefined,
+	): void {
+		if (toolActivity?.phase === "started") {
+			this.failLegacyToolStart(toolActivity);
+			return;
+		}
+		if (
+			toolActivity?.phase !== "terminal" ||
+			legacyToolStart === undefined ||
+			this.legacyToolStarts.get(legacyToolStart.key) !== legacyToolStart
+		)
+			return;
+		this.settleLegacyToolStart(legacyToolStart, "terminal");
+		this.liveMessages.delete(legacyToolStart.key);
+		if (this.toolActivityOwners.get(legacyToolStart.key) === legacyToolStart.owner)
+			this.toolActivityOwners.delete(legacyToolStart.key);
+	}
+
+	private cancelLegacyToolStartsForSession(session: SessionSocket): void {
+		for (const state of [...this.legacyToolStarts.values()]) {
+			if (state.owner.session !== session) continue;
+			if (!this.cancelUnsentLegacyToolStart(state)) this.settleLegacyToolStart(state, "cancelled");
+		}
+	}
+
+	private cleanLegacyToolStartsForCapabilityUpgrade(session: SessionSocket): void {
+		for (const state of [...this.legacyToolStarts.values()]) {
+			if (state.owner.session !== session || state.phase === "dispatching") continue;
+			if (state.phase === "visible") this.settleLegacyToolStart(state, "terminal");
+			else this.cancelUnsentLegacyToolStart(state);
+		}
+	}
+	private cancelLegacyToolStartsForPolicyTransition(): Promise<LegacyToolStartOutcome[]> {
+		const dispatching: Promise<LegacyToolStartOutcome>[] = [];
+		const visibleTerminalizations: Array<{ messageId: number; owner: ToolActivityOwner }> = [];
+		for (const state of [...this.legacyToolStarts.values()]) {
+			if (state.phase === "dispatching")
+				dispatching.push(
+					state.settled.then(outcome => {
+						if (outcome === "visible" && this.legacyToolStarts.get(state.key) === state) {
+							const messageId = this.liveMessages.get(state.key);
+							this.liveMessages.delete(state.key);
+							if (this.toolActivityOwners.get(state.key) === state.owner)
+								this.toolActivityOwners.delete(state.key);
+							this.settleLegacyToolStart(state, "terminal");
+							if (messageId !== undefined) {
+								void this.enqueueToolTerminalization([{ messageId, owner: state.owner }], false);
+							}
+						}
+						return outcome;
+					}),
+				);
+			else if (state.phase === "visible") {
+				const messageId = this.liveMessages.get(state.key);
+				this.liveMessages.delete(state.key);
+				if (this.toolActivityOwners.get(state.key) === state.owner) this.toolActivityOwners.delete(state.key);
+				this.settleLegacyToolStart(state, "terminal");
+				if (messageId !== undefined) {
+					visibleTerminalizations.push({ messageId, owner: state.owner });
+				}
+			} else this.cancelUnsentLegacyToolStart(state);
+		}
+		if (visibleTerminalizations.length > 0) {
+			void this.enqueueToolTerminalization(visibleTerminalizations, false);
+		}
+		return Promise.all(dispatching);
+	}
 	private toolActivityOwner(session: SessionSocket, msg: Record<string, unknown>): ToolActivityOwner | undefined {
 		if (msg.type !== "tool_activity") return undefined;
 		const toolCallId = typeof msg.toolCallId === "string" ? msg.toolCallId : undefined;
 		const toolName = typeof msg.toolName === "string" ? msg.toolName : undefined;
 		const phase = typeof msg.phase === "string" ? msg.phase : undefined;
-		if (!toolCallId || !toolName || !phase) return undefined;
+		if (
+			!toolCallId ||
+			!toolName ||
+			(phase !== "started" && phase !== "completed" && phase !== "failed" && phase !== "cancelled")
+		)
+			return undefined;
 		return {
 			sessionId: this.#logicalSessionId(session),
 			toolCallId,
@@ -5715,6 +6381,30 @@ export class TelegramNotificationDaemon {
 			phase: phase === "started" ? "started" : "terminal",
 		};
 	}
+	private renderThreadedFrame(frame: Record<string, unknown>): ThreadedSend | undefined {
+		if (
+			frame.type === "tool_activity" &&
+			frame.phase !== "started" &&
+			frame.phase !== "completed" &&
+			frame.phase !== "failed" &&
+			frame.phase !== "cancelled"
+		)
+			return undefined;
+		return renderThreadedFrame(frame);
+	}
+	private toolActivityFrameWithoutSummaries(frame: Record<string, unknown>): Record<string, unknown> {
+		const summaryFree = { ...frame };
+		delete summaryFree.argsSummary;
+		delete summaryFree.resultSummary;
+		return summaryFree;
+	}
+	private toolActivitySummariesAreCurrent(toolActivity: ToolActivityOwner): boolean {
+		return (
+			this.opts.toolActivity?.enabled === true &&
+			toolActivity.policyEpoch === this.toolActivityPolicyEpoch &&
+			this.toolActivityAuthorityIsCurrent(toolActivity)
+		);
+	}
 
 	private toolActivityAuthorityIsCurrent(toolActivity: ToolActivityOwner): boolean {
 		if (this.revokedToolEndpoints.has(toolActivity.endpointDigest)) return false;
@@ -5723,6 +6413,34 @@ export class TelegramNotificationDaemon {
 		if (toolActivity.endpointDigest === undefined) return session === undefined;
 		return session === toolActivity.session && session.endpointDigest === toolActivity.endpointDigest;
 	}
+	private toolActivityDeliveryIsCurrent(toolActivity: ToolActivityOwner): boolean {
+		const key = `${toolActivity.sessionId}:tool:${toolActivity.toolCallId}`;
+		const owner = this.toolActivityOwners.get(key);
+		if (owner && owner.session !== toolActivity.session) return false;
+		if (toolActivity.phase === "started") {
+			const legacyStart =
+				toolActivity.session.toolActivityCapability === "v1" ? this.legacyToolStarts.get(key) : undefined;
+			return (
+				(toolActivity.session.toolActivityCapability !== "v1" ||
+					(legacyStart !== undefined &&
+						legacyStart.owner === toolActivity &&
+						legacyStart.phase !== "cancelled" &&
+						legacyStart.phase !== "failed" &&
+						legacyStart.phase !== "terminal")) &&
+				this.toolActivityAuthorityIsCurrent(toolActivity) &&
+				!this.toolActivityStopping &&
+				this.opts.toolActivity?.enabled === true &&
+				toolActivity.policyEpoch === this.toolActivityPolicyEpoch
+			);
+		}
+		if (
+			this.toolActivityAuthorityIsCurrent(toolActivity) &&
+			this.opts.toolActivity?.enabled === true &&
+			toolActivity.policyEpoch === this.toolActivityPolicyEpoch
+		)
+			return true;
+		return this.liveMessages.has(key) && owner?.session === toolActivity.session;
+	}
 	private async submitThreadedFrame(
 		sessionId: string,
 		send: ThreadedSend,
@@ -5730,17 +6448,45 @@ export class TelegramNotificationDaemon {
 		toolActivity?: ToolActivityOwner,
 		socketLease?: { session: SessionSocket; token: number; logicalSessionId: string },
 	): Promise<void> {
-		this.submitPool({
+		const legacyStart =
+			toolActivity?.phase === "started"
+				? this.legacyToolStarts.get(`${toolActivity.sessionId}:tool:${toolActivity.toolCallId}`)
+				: toolActivity?.phase === "terminal"
+					? this.legacyToolStartForTerminal(toolActivity)
+					: undefined;
+		if (legacyStart !== undefined && legacyStart.owner === toolActivity) {
+			if (toolActivity!.phase === "started") {
+				legacyStart.phase = "queued";
+				legacyStart.itemId ??= `legacy-tool-start:${this.nextLegacyToolStartId++}`;
+			}
+		}
+		// Terminal frames get a distinct pool item identity so they cannot collide
+		// with an in-flight start for the same legacy settlement.
+		const poolItemId =
+			legacyStart !== undefined && legacyStart.owner === toolActivity
+				? toolActivity!.phase === "terminal"
+					? `legacy-tool-terminal:${this.nextLegacyToolStartId++}`
+					: legacyStart.itemId
+				: undefined;
+		const submitted = this.submitPool({
 			sessionId,
 			lane: send.lane,
 			coalesceKey: send.coalesceKey,
+			...(poolItemId !== undefined ? { itemId: poolItemId } : {}),
 			payload: {
 				send,
 				topicLease,
 				...(socketLease ? { socketLease } : {}),
 				...(toolActivity ? { toolActivity } : {}),
+				...(legacyStart !== undefined && toolActivity?.phase === "terminal"
+					? { legacyToolStart: legacyStart }
+					: {}),
 			},
 		});
+		if (!submitted) {
+			this.settleRejectedLegacyToolSubmission(toolActivity, legacyStart);
+			return;
+		}
 		await this.flushPool();
 	}
 
@@ -5810,8 +6556,16 @@ export class TelegramNotificationDaemon {
 	): void {
 		const logicalSessionId = this.#logicalSessionId(session);
 		const socketLease = this.#socketLease(session, logicalSessionId);
-		if (!socketLease) return;
+		if (!socketLease) {
+			this.failLegacyToolStart(toolActivity);
+			return;
+		}
 		const frames = this.pendingThreadedFrames.get(logicalSessionId) ?? [];
+		const legacyStart =
+			toolActivity?.phase === "started"
+				? this.legacyToolStarts.get(`${toolActivity.sessionId}:tool:${toolActivity.toolCallId}`)
+				: undefined;
+		if (legacyStart !== undefined && legacyStart.owner === toolActivity) legacyStart.phase = "pending_identity";
 		frames.push({
 			send,
 			msg,
@@ -5819,7 +6573,10 @@ export class TelegramNotificationDaemon {
 			socketLease,
 			...(toolActivity ? { toolActivity } : {}),
 		});
-		if (frames.length > PENDING_TOPIC_FRAME_LIMIT) frames.shift();
+		if (frames.length > PENDING_TOPIC_FRAME_LIMIT) {
+			const evicted = frames.shift();
+			this.failLegacyToolStart(evicted?.toolActivity);
+		}
 		this.pendingThreadedFrames.set(logicalSessionId, frames);
 	}
 
@@ -5828,8 +6585,14 @@ export class TelegramNotificationDaemon {
 		if (!frames || frames.length === 0) return;
 		this.pendingThreadedFrames.delete(sessionId);
 		for (const frame of frames) {
-			if (frame.logicalSessionId !== sessionId || !this.#leaseTokenAllows(frame.socketLease)) continue;
-			if (frame.msg.type === "tool_activity" && this.opts.toolActivity?.enabled === false) continue;
+			if (
+				frame.logicalSessionId !== sessionId ||
+				!this.#leaseTokenAllows(frame.socketLease) ||
+				(frame.msg.type === "tool_activity" && this.opts.toolActivity?.enabled !== true)
+			) {
+				this.failLegacyToolStart(frame.toolActivity);
+				continue;
+			}
 			await this.submitThreadedFrame(sessionId, frame.send, topicLease, frame.toolActivity, frame.socketLease);
 		}
 	}
@@ -5868,13 +6631,20 @@ export class TelegramNotificationDaemon {
 		let acceptedTopicId: string | undefined;
 		let acceptedTopicCompensated = false;
 		let acceptedTopicDeleteAttempted = false;
+		let creationSuppressed = false;
 		try {
 			const rec = await this.topics.getOrCreateTopic(
 				sessionId,
 				async () => {
 					if (capturedCreationLease && !this.#leaseTokenAllows(capturedCreationLease))
 						throw new Error("topic authority was revoked during creation");
-					const res = await this.botApi.call("createForumTopic", { chat_id: this.opts.chatId, name });
+					const res = (await this.botApi.call("createForumTopic", { chat_id: this.opts.chatId, name })) as
+						| { result?: { message_thread_id?: unknown } }
+						| undefined;
+					if (res === undefined) {
+						creationSuppressed = true;
+						return undefined;
+					}
 					if (isThreadedModeCapabilityRefusal(res)) throw new ThreadedModeCapabilityRefusal();
 					const response = res as {
 						ok?: unknown;
@@ -5958,7 +6728,7 @@ export class TelegramNotificationDaemon {
 			}
 			return rec.topicId;
 		} catch (err) {
-			if (err instanceof ThreadedModeCapabilityRefusal) return undefined;
+			if (creationSuppressed || err instanceof ThreadedModeCapabilityRefusal) return undefined;
 			if (
 				acceptedTopicId &&
 				!acceptedTopicCompensated &&
@@ -6445,6 +7215,7 @@ export class TelegramNotificationDaemon {
 				this.finishSelectedAck(expiredItem.payload.selectedAck, { status: "failed", reason: "expired" });
 			}
 			expiredItem.payload.btwDelivery?.finish("not_delivered");
+			this.failLegacyToolStart(expiredItem.payload.toolActivity);
 		}
 		// Within a batch a finalized frame supersedes any still-queued live frame for
 		// the same streamed message (finalized outranks live), so drop the stale live
@@ -6469,17 +7240,18 @@ export class TelegramNotificationDaemon {
 		}
 		for (const item of batch) {
 			const toolActivity = item.payload.toolActivity;
-			if (
-				toolActivity?.phase === "started" &&
-				(this.toolActivityStopping ||
-					this.opts.toolActivity?.enabled === false ||
-					toolActivity.policyEpoch !== this.toolActivityPolicyEpoch ||
-					!this.toolActivityAuthorityIsCurrent(toolActivity))
-			) {
+			const legacyStart =
+				toolActivity?.phase === "started"
+					? this.legacyToolStarts.get(`${toolActivity.sessionId}:tool:${toolActivity.toolCallId}`)
+					: undefined;
+			if (legacyStart !== undefined && legacyStart.owner === toolActivity && legacyStart.phase === "queued")
+				legacyStart.phase = "dispatching";
+			if (toolActivity && !this.toolActivityDeliveryIsCurrent(toolActivity)) {
 				const key = `${toolActivity.sessionId}:tool:${toolActivity.toolCallId}`;
 				const owner = this.toolActivityOwners.get(key);
 				if (!this.liveMessages.has(key) && owner?.session === toolActivity.session)
 					this.toolActivityOwners.delete(key);
+				this.failLegacyToolStart(toolActivity);
 				this.pool.settle(item.itemId!, "removed");
 				continue;
 			}
@@ -6496,14 +7268,32 @@ export class TelegramNotificationDaemon {
 					continue;
 				}
 				try {
-					const response = await this.botApi.call("sendMessage", btwDelivery.body, {
+					const { outcome } = await this.callBotApiClassified("sendMessage", btwDelivery.body, {
 						noRetry: true,
 						signal: btwDelivery.signal,
 					});
-					const accepted = response && typeof response === "object" && (response as { ok?: unknown }).ok === true;
-					const rejected = response && typeof response === "object" && (response as { ok?: unknown }).ok === false;
-					btwDelivery.finish(accepted ? "accepted" : rejected ? "not_delivered" : "uncertain");
-					this.pool.settle(item.itemId!, accepted ? "accepted" : rejected ? "rejected" : "ambiguous");
+					if (outcome.kind === "retryable") {
+						this.submitPool({
+							sessionId: item.sessionId,
+							lane: item.lane,
+							coalesceKey: item.coalesceKey,
+							deadlineAt: item.deadlineAt,
+							payload: item.payload,
+						});
+						this.pool.settle(item.itemId!, "ambiguous");
+						continue;
+					}
+					btwDelivery.finish(
+						outcome.kind === "accepted"
+							? "accepted"
+							: outcome.kind === "rejected"
+								? "not_delivered"
+								: "uncertain",
+					);
+					this.pool.settle(
+						item.itemId!,
+						outcome.kind === "accepted" ? "accepted" : outcome.kind === "rejected" ? "rejected" : "ambiguous",
+					);
 				} catch {
 					btwDelivery.finish("uncertain");
 					this.pool.settle(item.itemId!, "ambiguous");
@@ -6549,7 +7339,7 @@ export class TelegramNotificationDaemon {
 						this.pool.settle(item.itemId!, "rejected");
 						continue;
 					}
-					const response = (await this.botApi.call(
+					const { response, outcome } = await this.callBotApiClassified(
 						"sendMessage",
 						{
 							chat_id: this.opts.chatId,
@@ -6557,9 +7347,28 @@ export class TelegramNotificationDaemon {
 							text: "Selected!",
 						},
 						{ signal: controller.signal, noRetry: true },
-					)) as { ok?: unknown; result?: { message_id?: unknown } };
-					const messageId = response.result?.message_id;
-					const delivered = response.ok === true && typeof messageId === "number";
+					);
+					if (outcome.kind === "retryable") {
+						this.pool.settle(item.itemId!, "ambiguous");
+						if (this.effects.stopping) {
+							this.finishSelectedAck(selectedAck, { status: "unknown", reason: "shutdown" });
+						} else {
+							const retry = this.pool.submit({
+								sessionId: item.sessionId,
+								lane: item.lane,
+								coalesceKey: item.coalesceKey,
+								deadlineAt: item.deadlineAt,
+								payload: item.payload,
+							});
+							selectedAck.itemId = retry.itemId;
+							selectedAck.state = "queued";
+							selectedAck.controller = undefined;
+						}
+						continue;
+					}
+					const typedResponse = response as { ok?: unknown; result?: { message_id?: unknown } } | undefined;
+					const messageId = typedResponse?.result?.message_id;
+					const delivered = typedResponse?.ok === true && typeof messageId === "number";
 					this.finishSelectedAck(
 						selectedAck,
 						delivered ? { status: "delivered", messageId } : { status: "failed", reason: "telegram_rejected" },
@@ -6573,17 +7382,20 @@ export class TelegramNotificationDaemon {
 				}
 				continue;
 			}
-			const { send, topicLease, socketLease } = item.payload;
+			let { send } = item.payload;
+			const { topicLease, socketLease } = item.payload;
 			if (
 				(socketLease && !this.#leaseTokenAllows(socketLease)) ||
 				(topicLease && !this.topicLeaseIsCurrent(topicLease))
 			) {
 				this.pool.settle(item.itemId!, "rejected");
+				this.failLegacyToolStart(toolActivity);
 				continue;
 			}
 			const topicId = topicLease?.topicId;
 			if (topicId && !(await this.pairedChatIsPrivate())) {
 				this.pool.settle(item.itemId!, "rejected");
+				this.failLegacyToolStart(toolActivity);
 				continue;
 			}
 			if (
@@ -6591,12 +7403,20 @@ export class TelegramNotificationDaemon {
 				(topicLease && !this.topicLeaseIsCurrent(topicLease))
 			) {
 				this.pool.settle(item.itemId!, "rejected");
+				this.failLegacyToolStart(toolActivity);
 				continue;
 			}
 			if (item.payload.toolActivity && !this.toolActivityAuthorityIsCurrent(item.payload.toolActivity)) {
 				this.pool.settle(item.itemId!, "removed");
+				this.failLegacyToolStart(toolActivity);
 				continue;
 			}
+			if (
+				toolActivity?.phase === "terminal" &&
+				!this.toolActivitySummariesAreCurrent(toolActivity) &&
+				toolActivity.summaryFreeSend
+			)
+				send = toolActivity.summaryFreeSend;
 			// Threaded topic when available; otherwise deliver flat to the paired chat.
 			const threadField = topicId ? { message_thread_id: Number(topicId) } : {};
 			const ckey = send.editable ? item.coalesceKey : undefined;
@@ -6605,6 +7425,8 @@ export class TelegramNotificationDaemon {
 				this.pool.settle(item.itemId!, "removed");
 				continue;
 			}
+			const itemOutcomes: BotApiCallOutcome[] = [];
+			const itemBotApi = this.botApiWithOutcomeCollector(itemOutcomes);
 			let disposition: "accepted" | "ambiguous" | "rejected" = "accepted";
 			try {
 				// Draft streaming (opt-in, off by default): stream a live turn frame as a
@@ -6643,7 +7465,7 @@ export class TelegramNotificationDaemon {
 				}
 				if (send.method === "sendPhoto" && send.photoBase64) {
 					// Real photo upload (the default botApi multiparts base64 -> file).
-					await this.botApi.call("sendPhoto", {
+					await itemBotApi.call("sendPhoto", {
 						chat_id: this.opts.chatId,
 						...threadField,
 						photo: send.photoBase64,
@@ -6652,7 +7474,7 @@ export class TelegramNotificationDaemon {
 						parse_mode: TELEGRAM_PARSE_MODE,
 					});
 				} else if (send.method === "sendDocument" && send.documentBase64) {
-					await this.botApi.call("sendDocument", {
+					await itemBotApi.call("sendDocument", {
 						chat_id: this.opts.chatId,
 						...threadField,
 						document: send.documentBase64,
@@ -6682,7 +7504,7 @@ export class TelegramNotificationDaemon {
 								(topicLease && !this.topicLeaseIsCurrent(topicLease))
 							)
 								return;
-							await this.botApi.call("sendMessage", {
+							await itemBotApi.call("sendMessage", {
 								chat_id: this.opts.chatId,
 								...threadField,
 								text: chunks[0]!,
@@ -6712,7 +7534,7 @@ export class TelegramNotificationDaemon {
 							}
 						};
 						const richMessageId = await deliverRichWithFallback(
-							this.botApi,
+							itemBotApi,
 							{ chat_id: this.opts.chatId, ...threadField },
 							send,
 							AbortSignal.any([this.#deliveryAbort.signal, AbortSignal.timeout(30_000)]),
@@ -6746,13 +7568,13 @@ export class TelegramNotificationDaemon {
 									(topicLease && !this.topicLeaseIsCurrent(topicLease))
 								)
 									return;
-								const res = (await this.botApi.call("editMessageText", {
+								const res = (await itemBotApi.call("editMessageText", {
 									chat_id: this.opts.chatId,
 									message_id: existingId,
 									text: chunks[0],
 									parse_mode: TELEGRAM_PARSE_MODE,
 								})) as { ok?: boolean; description?: string } | null;
-								edited = res?.ok !== false || /not modified/i.test(String(res?.description ?? ""));
+								edited = res?.ok === true || /not modified/i.test(String(res?.description ?? ""));
 							} catch {
 								edited = false;
 							}
@@ -6762,7 +7584,7 @@ export class TelegramNotificationDaemon {
 								(!socketLease || this.#leaseTokenAllows(socketLease)) &&
 								(!topicLease || this.topicLeaseIsCurrent(topicLease))
 							) {
-								const res = (await this.botApi.call("sendMessage", {
+								const res = (await itemBotApi.call("sendMessage", {
 									chat_id: this.opts.chatId,
 									...threadField,
 									text: chunks[0]!,
@@ -6778,7 +7600,7 @@ export class TelegramNotificationDaemon {
 								(topicLease && !this.topicLeaseIsCurrent(topicLease))
 							)
 								return;
-							const res = (await this.botApi.call("sendMessage", {
+							const res = (await itemBotApi.call("sendMessage", {
 								chat_id: this.opts.chatId,
 								...threadField,
 								text: chunks[0]!,
@@ -6826,11 +7648,79 @@ export class TelegramNotificationDaemon {
 				disposition = "ambiguous";
 				if (item.payload.toolActivity?.phase === "started") this.toolActivityAmbiguous = true;
 			} finally {
+				const retryable = itemOutcomes.some(outcome => outcome.kind === "retryable");
+				const accepted = itemOutcomes.some(outcome => outcome.kind === "accepted");
+				const rejected = itemOutcomes.some(outcome => outcome.kind === "rejected");
+				if (retryable) {
+					if (!accepted) {
+						let retryItemId: string | undefined;
+						let retryAllowed = true;
+						if (toolActivity?.phase === "started") {
+							retryAllowed =
+								!this.toolActivityStopping &&
+								!this.stopRequested &&
+								this.opts.toolActivity?.enabled === true &&
+								toolActivity.policyEpoch === this.toolActivityPolicyEpoch &&
+								this.toolActivityAuthorityIsCurrent(toolActivity);
+							if (toolActivity.session.toolActivityCapability === "v1") {
+								const state = this.legacyToolStarts.get(
+									`${toolActivity.sessionId}:tool:${toolActivity.toolCallId}`,
+								);
+								retryAllowed =
+									retryAllowed &&
+									state !== undefined &&
+									state.owner === toolActivity &&
+									!state.terminalClaimed;
+								if (state !== undefined && state.owner === toolActivity) {
+									if (retryAllowed) {
+										state.phase = "queued";
+										state.itemId = `legacy-tool-start:${this.nextLegacyToolStartId++}`;
+										retryItemId = state.itemId;
+									} else {
+										this.settleLegacyToolStart(state, "cancelled");
+									}
+								}
+							} else if (retryAllowed) {
+								retryItemId = `tool-activity-start:${this.nextLegacyToolStartId++}`;
+							}
+						} else if (toolActivity?.phase === "terminal" && item.payload.legacyToolStart !== undefined) {
+							retryItemId = `legacy-tool-terminal:${this.nextLegacyToolStartId++}`;
+						}
+						const newerCoalescedItem =
+							toolActivity === undefined &&
+							item.coalesceKey !== undefined &&
+							this.pool.someQueued(
+								queued =>
+									queued.sessionId === item.sessionId &&
+									queued.lane === item.lane &&
+									queued.coalesceKey === item.coalesceKey,
+							);
+						if (retryAllowed && !newerCoalescedItem) {
+							this.submitPool({
+								sessionId: item.sessionId,
+								lane: item.lane,
+								coalesceKey: item.coalesceKey,
+								deadlineAt: item.deadlineAt,
+								...(retryItemId !== undefined ? { itemId: retryItemId } : {}),
+								payload: item.payload,
+							});
+						}
+					}
+					disposition = "ambiguous";
+				} else if (disposition === "accepted" && !accepted && rejected) {
+					disposition = "rejected";
+				}
 				this.pool.settle(item.itemId!, disposition);
+				if (toolActivity?.phase === "started" && !retryable) this.failLegacyToolStart(toolActivity);
+				if (toolActivity?.phase === "terminal" && !retryable) {
+					const state = item.payload.legacyToolStart;
+					if (state !== undefined && this.legacyToolStarts.get(state.key) === state)
+						this.settleLegacyToolStart(state, "terminal");
+				}
 				// A terminal tool frame owns the end of this coalescing key even when both
 				// edit and fallback delivery fail. Retaining the old message id would leak
 				// one entry per failure and let a later reused key edit stale Telegram state.
-				if (send.terminal && editKey) {
+				if (send.terminal && editKey && !retryable) {
 					this.liveMessages.delete(editKey);
 					const owner = this.toolActivityOwners.get(editKey);
 					if (!item.payload.toolActivity || owner?.session === item.payload.toolActivity.session)
@@ -6866,6 +7756,18 @@ export class TelegramNotificationDaemon {
 			}
 		}
 		if (toolActivity) {
+			const legacyStart = this.legacyToolStarts.get(mapKey);
+			if (
+				legacyStart !== undefined &&
+				legacyStart.owner === toolActivity &&
+				(toolActivity.session.toolActivityCapability !== "v1" ||
+					legacyStart.policyEpoch !== this.toolActivityPolicyEpoch ||
+					!this.toolActivityAuthorityIsCurrent(toolActivity))
+			) {
+				this.settleLegacyToolStart(legacyStart, "terminal");
+				void this.enqueueToolTerminalization([{ messageId, owner: toolActivity }], false);
+				return;
+			}
 			const owner = this.toolActivityOwners.get(mapKey);
 			if (this.revokedToolEndpoints.has(toolActivity.endpointDigest) || owner?.session !== toolActivity.session) {
 				void this.enqueueToolTerminalization([{ messageId, owner: toolActivity }], false);
@@ -6874,6 +7776,10 @@ export class TelegramNotificationDaemon {
 		}
 		this.liveMessages.set(mapKey, messageId);
 		if (toolActivity) this.toolActivityOwners.set(mapKey, toolActivity);
+		if (toolActivity) {
+			const state = this.legacyToolStarts.get(mapKey);
+			if (state !== undefined && state.owner === toolActivity) this.settleLegacyToolStart(state, "visible");
+		}
 	}
 
 	/**
@@ -6892,16 +7798,50 @@ export class TelegramNotificationDaemon {
 		socketLease?: { session: SessionSocket; token: number; logicalSessionId: string },
 	): Promise<void> {
 		if ((socketLease && !this.#leaseTokenAllows(socketLease)) || !(await this.pairedChatIsPrivate())) return;
+		if (toolActivity && !this.toolActivityDeliveryIsCurrent(toolActivity)) return;
 		if (socketLease && !this.#leaseTokenAllows(socketLease)) return;
 		await this.notifyThreadedFallback(socketLease);
+		if (toolActivity && !this.toolActivityDeliveryIsCurrent(toolActivity)) return;
 		if (socketLease && !this.#leaseTokenAllows(socketLease)) return;
+		if (toolActivity && !this.toolActivityDeliveryIsCurrent(toolActivity)) return;
 		if (send.identity && this.flatIdentitySent.has(sessionId)) return;
-		this.submitPool({
+		if (toolActivity && !this.toolActivityDeliveryIsCurrent(toolActivity)) return;
+		const legacyToolStart =
+			toolActivity?.phase === "started"
+				? this.legacyToolStarts.get(`${toolActivity.sessionId}:tool:${toolActivity.toolCallId}`)
+				: toolActivity?.phase === "terminal"
+					? this.legacyToolStartForTerminal(toolActivity)
+					: undefined;
+		if (
+			legacyToolStart !== undefined &&
+			legacyToolStart.owner === toolActivity &&
+			toolActivity?.phase === "started"
+		) {
+			legacyToolStart.phase = "queued";
+			legacyToolStart.itemId ??= `legacy-tool-start:${this.nextLegacyToolStartId++}`;
+		}
+		const poolItemId =
+			legacyToolStart !== undefined && legacyToolStart.owner === toolActivity
+				? toolActivity!.phase === "terminal"
+					? `legacy-tool-terminal:${this.nextLegacyToolStartId++}`
+					: legacyToolStart.itemId
+				: undefined;
+		const submitted = this.submitPool({
 			sessionId,
 			lane: send.lane,
 			coalesceKey: send.coalesceKey,
-			payload: { send, ...(socketLease ? { socketLease } : {}), ...(toolActivity ? { toolActivity } : {}) },
+			...(poolItemId !== undefined ? { itemId: poolItemId } : {}),
+			payload: {
+				send,
+				...(socketLease ? { socketLease } : {}),
+				...(toolActivity ? { toolActivity } : {}),
+				...(legacyToolStart !== undefined && toolActivity?.phase === "terminal" ? { legacyToolStart } : {}),
+			},
 		});
+		if (!submitted) {
+			this.settleRejectedLegacyToolSubmission(toolActivity, legacyToolStart);
+			return;
+		}
 		await this.flushPool();
 		if (socketLease && !this.#leaseTokenAllows(socketLease)) return;
 		if (send.identity) this.flatIdentitySent.add(sessionId);
@@ -6920,6 +7860,7 @@ export class TelegramNotificationDaemon {
 				ok?: unknown;
 				result?: { type?: unknown };
 			};
+			if (res === undefined) return "indeterminate";
 			if (res?.ok !== true) {
 				logger.warn("notifications: getChat privacy check indeterminate (non-success response)");
 				return "indeterminate";
@@ -6982,12 +7923,10 @@ export class TelegramNotificationDaemon {
 		this.runtime.stopInterval("telegram-flush");
 	}
 	private async renewOwnershipHeartbeat(): Promise<boolean> {
-		return renewDaemonHeartbeat({
+		return renewOwnerHeartbeatSidecar({
 			settings: this.opts.settings,
 			ownerId: this.opts.ownerId,
 			acquisitionId: this.opts.ownerId,
-			tokenFingerprint: tokenFingerprint(this.opts.botToken),
-			chatId: this.opts.chatId,
 			fs: this.fsImpl,
 			now: this.opts.now,
 			pid: this.opts.pid ?? process.pid,
@@ -7145,7 +8084,7 @@ export class TelegramNotificationDaemon {
 				parse_mode: TELEGRAM_PARSE_MODE,
 				reply_markup: { inline_keyboard },
 			});
-			if (response && typeof response === "object" && (response as { ok?: unknown }).ok === false) {
+			if (!response || typeof response !== "object" || (response as { ok?: unknown }).ok !== true) {
 				for (const alias of aliases) this.#modelChoiceAliases.delete(alias);
 				logger.warn("notifications: failed to send model selection keyboard");
 				return false;
@@ -7161,6 +8100,10 @@ export class TelegramNotificationDaemon {
 	async handleSessionMessage(session: SessionSocket, msg: any): Promise<void> {
 		if (msg?.type === "hello") {
 			const capabilities = Array.isArray(msg.capabilities) ? msg.capabilities : [];
+			const previousToolActivityCapability = session.toolActivityCapability;
+			session.toolActivityCapability = negotiateToolActivityCapability(previousToolActivityCapability, capabilities);
+			if (previousToolActivityCapability === "v1" && session.toolActivityCapability === "v2")
+				this.cleanLegacyToolStartsForCapabilityUpgrade(session);
 			if (capabilities.includes("ephemeral_turn_v1")) {
 				session.ephemeralCapable = true;
 				this.#resumeBtwTurnsForSession(session);
@@ -7172,7 +8115,7 @@ export class TelegramNotificationDaemon {
 			return;
 		}
 		if (session.replayPending) {
-			if (msg?.type === "tool_activity" && (this.opts.toolActivity?.enabled === false || this.toolActivityStopping))
+			if (msg?.type === "tool_activity" && (this.opts.toolActivity?.enabled !== true || this.toolActivityStopping))
 				return;
 			const matchingReplay = msg?.type === "event_replay_result" && msg.id === session.replayId;
 			if (!matchingReplay) {
@@ -7526,34 +8469,76 @@ export class TelegramNotificationDaemon {
 			return;
 		}
 		if (typeof msg?.type === "string" && TelegramNotificationDaemon.THREADED_FRAMES.has(msg.type)) {
-			const threadedFrame = msg as Record<string, unknown>;
+			let threadedFrame = msg as Record<string, unknown>;
+			let legacyUnknownStart: LegacyToolStartSettlement | undefined;
+			if (threadedFrame.type === "tool_activity" && threadedFrame.phase === "unknown") {
+				const toolCallId = typeof threadedFrame.toolCallId === "string" ? threadedFrame.toolCallId : undefined;
+				const toolName = typeof threadedFrame.toolName === "string" ? threadedFrame.toolName : undefined;
+				const liveKey = toolCallId ? `${this.#logicalSessionId(session)}:tool:${toolCallId}` : undefined;
+				const state = liveKey ? this.legacyToolStarts.get(liveKey) : undefined;
+				if (
+					session.toolActivityCapability !== "v1" ||
+					!state ||
+					state.owner.session !== session ||
+					state.owner.toolName !== toolName ||
+					state.terminalClaimed
+				)
+					return;
+				state.terminalClaimed = true;
+				if (this.cancelUnsentLegacyToolStart(state)) return;
+				if (state.phase === "dispatching") await state.settled;
+				if (
+					state.settledOutcome !== "visible" ||
+					this.legacyToolStarts.get(state.key) !== state ||
+					session.toolActivityCapability !== "v1" ||
+					state.owner.session !== session ||
+					state.policyEpoch !== this.toolActivityPolicyEpoch ||
+					!this.toolActivityAuthorityIsCurrent(state.owner) ||
+					this.toolActivityOwners.get(state.key) !== state.owner ||
+					!this.liveMessages.has(state.key)
+				)
+					return;
+				legacyUnknownStart = state;
+				threadedFrame = { ...this.toolActivityFrameWithoutSummaries(threadedFrame), phase: "cancelled" };
+			}
 			const toolActivity = this.toolActivityOwner(session, threadedFrame);
+			if (threadedFrame.type === "tool_activity" && !toolActivity) return;
 			const toolAdmissionEpoch = toolActivity
 				? (this.replayToolActivityEpochs.get(threadedFrame) ?? this.toolActivityPolicyEpoch)
 				: undefined;
 			if (toolActivity) toolActivity.policyEpoch = toolAdmissionEpoch;
-			const toolStartIsCurrent = (): boolean =>
-				toolActivity?.phase !== "started" ||
-				(this.toolActivityAuthorityIsCurrent(toolActivity) &&
-					!this.toolActivityStopping &&
-					this.opts.toolActivity?.enabled !== false &&
-					toolAdmissionEpoch === this.toolActivityPolicyEpoch);
+			if (toolActivity?.phase === "started" && toolActivity.session.toolActivityCapability === "v1") {
+				const state = this.admitLegacyToolStart(toolActivity);
+				if (!state) return;
+			}
+			if (legacyUnknownStart && toolActivity?.phase === "terminal") {
+				if (
+					legacyUnknownStart.owner.session !== toolActivity.session ||
+					legacyUnknownStart.key !== `${toolActivity.sessionId}:tool:${toolActivity.toolCallId}`
+				)
+					return;
+			}
+			const toolFrameIsCurrent = (): boolean => !toolActivity || this.toolActivityDeliveryIsCurrent(toolActivity);
 			const abandonStaleToolStart = (): void => {
 				if (toolActivity?.phase !== "started") return;
 				const key = `${toolActivity.sessionId}:tool:${toolActivity.toolCallId}`;
 				const owner = this.toolActivityOwners.get(key);
 				if (!this.liveMessages.has(key) && owner?.session === toolActivity.session)
 					this.toolActivityOwners.delete(key);
+				this.failLegacyToolStart(toolActivity);
 			};
 			if (toolActivity) {
 				const liveKey = `${toolActivity.sessionId}:tool:${toolActivity.toolCallId}`;
 				const currentOwner = this.toolActivityOwners.get(liveKey);
 				if (toolActivity.phase === "started") {
-					if (!toolStartIsCurrent()) return;
+					if (!toolFrameIsCurrent()) {
+						this.failLegacyToolStart(toolActivity);
+						return;
+					}
 					this.toolActivityOwners.set(liveKey, toolActivity);
 				} else {
 					if (currentOwner && currentOwner.session !== session) return;
-					if (this.opts.toolActivity?.enabled === false) {
+					if (this.opts.toolActivity?.enabled !== true) {
 						if (!currentOwner) return;
 						if (!this.liveMessages.has(liveKey)) {
 							// A start may already be granted to the serialized dispatcher but not
@@ -7569,8 +8554,21 @@ export class TelegramNotificationDaemon {
 					}
 				}
 			}
-			const send = renderThreadedFrame(msg);
-			if (!send) return;
+			const summaryFreeToolFrame =
+				toolActivity?.phase === "terminal" ? this.toolActivityFrameWithoutSummaries(threadedFrame) : threadedFrame;
+			const renderedFrame =
+				toolActivity?.phase === "terminal" && !this.toolActivitySummariesAreCurrent(toolActivity)
+					? summaryFreeToolFrame
+					: threadedFrame;
+			const send = this.renderThreadedFrame(renderedFrame);
+			if (toolActivity?.phase === "terminal") {
+				const summaryFreeSend = this.renderThreadedFrame(summaryFreeToolFrame);
+				if (summaryFreeSend) toolActivity.summaryFreeSend = summaryFreeSend;
+			}
+			if (!send) {
+				this.failLegacyToolStart(toolActivity);
+				return;
+			}
 			const transportLogicalSessionId = this.#logicalSessionId(session);
 			// Preserve legacy identity routing for direct/non-replay session callers.
 			// Authenticated transports never infer topic ownership from display identity:
@@ -7579,19 +8577,27 @@ export class TelegramNotificationDaemon {
 				send.identity && !session.logicalSessionIdTrusted && this.sessions.get(session.sessionId) !== session
 					? (this.topicOwnerForIdentity(msg) ?? transportLogicalSessionId)
 					: transportLogicalSessionId;
-			if (!this.#leaseAllows(session, logicalSessionId)) return;
+			if (!this.#leaseAllows(session, logicalSessionId)) {
+				this.failLegacyToolStart(toolActivity);
+				return;
+			}
 			const socketLease = this.#socketLease(session, logicalSessionId);
-			if (!socketLease) return;
+			if (!socketLease) {
+				this.failLegacyToolStart(toolActivity);
+				return;
+			}
 			const existingTopic = await this.existingTopicForPrivateChat(logicalSessionId);
-			if (!toolStartIsCurrent()) {
+			if (!toolFrameIsCurrent()) {
 				abandonStaleToolStart();
 				return;
 			}
 			if (
 				this.topics.get(logicalSessionId)?.authorityState === "delete_pending" ||
 				this.topics.get(logicalSessionId)?.bindingMalformed
-			)
+			) {
+				this.failLegacyToolStart(toolActivity);
 				return;
+			}
 			if (!send.identity && !existingTopic && !this.flatIdentitySent.has(logicalSessionId)) {
 				this.rememberPendingThreadedFrame(session, send, threadedFrame, toolActivity);
 				return;
@@ -7604,8 +8610,14 @@ export class TelegramNotificationDaemon {
 				if (
 					this.topics.get(logicalSessionId)?.authorityState === "delete_pending" ||
 					this.topics.get(logicalSessionId)?.bindingMalformed
-				)
+				) {
+					this.failLegacyToolStart(toolActivity);
 					return;
+				}
+				if (!toolFrameIsCurrent()) {
+					abandonStaleToolStart();
+					return;
+				}
 				await this.deliverFlatFallback(logicalSessionId, send, toolActivity, socketLease);
 				return;
 			}
@@ -7647,7 +8659,7 @@ export class TelegramNotificationDaemon {
 				await this.reconcileUserTopicName(topicLease);
 				return;
 			}
-			if (!toolStartIsCurrent()) {
+			if (!toolFrameIsCurrent()) {
 				abandonStaleToolStart();
 				return;
 			}
@@ -7726,7 +8738,7 @@ export class TelegramNotificationDaemon {
 			// returns the last chunk's message_id (the reply-routable message).
 			const sendHtmlChunks = async (): Promise<number | undefined> => {
 				const chunks = splitTelegramHtml(rendered.text);
-				let result: { result?: { message_id?: number } } = {};
+				let result: { result?: { message_id?: number } } | undefined;
 				for (let i = 0; i < chunks.length; i++) {
 					if (!this.#leaseTokenAllows(socketLease) || (topicLease && !this.topicLeaseIsCurrent(topicLease)))
 						return undefined;
@@ -7736,9 +8748,10 @@ export class TelegramNotificationDaemon {
 						text: chunks[i]!,
 						parse_mode: TELEGRAM_PARSE_MODE,
 						...(i === chunks.length - 1 && inline_keyboard.length ? { reply_markup: { inline_keyboard } } : {}),
-					})) as { result?: { message_id?: number } };
+					})) as { result?: { message_id?: number } } | undefined;
+					if (result === undefined) return undefined;
 				}
-				return result.result?.message_id;
+				return result?.result?.message_id;
 			};
 			const kind = msg.kind === "idle" ? "idle" : "ask";
 			if (this.opts.rich?.enabled !== false) {
@@ -8042,6 +9055,7 @@ export class TelegramNotificationDaemon {
 					? "notifications.telegram.rich.enabled"
 					: "notifications.telegram.toolActivity.enabled";
 				const label = isRichCommand ? "Rich messages" : "Tool activity";
+				const toolActivityChanged = isRichCommand || this.opts.toolActivity?.enabled !== desired;
 				try {
 					await this.opts.settings.set(settingPath, desired);
 					// Confirm only after the global config write is durable.
@@ -8055,13 +9069,26 @@ export class TelegramNotificationDaemon {
 				}
 				if (isRichCommand) {
 					this.opts.rich = { enabled: desired };
-				} else {
+				} else if (toolActivityChanged) {
 					this.toolActivityPolicyEpoch++;
 					this.opts.toolActivity = { enabled: desired };
+					const legacySettlements = this.cancelLegacyToolStartsForPolicyTransition();
 					if (!desired) {
-						const removedTools = this.pool.removeWhere(
-							item => item.lane === "live" && item.coalesceKey?.startsWith("tool:") === true,
-						);
+						// Unsent legacy starts are cancelled by exact item/frame identity; a
+						// dispatch already inside Bot API is joined through its own settlement.
+						await legacySettlements;
+						await this.flushChain;
+						const removedTools = this.pool.removeWhere(item => {
+							const toolActivity = item.payload.toolActivity;
+							if (!toolActivity) return false;
+							if (toolActivity.phase === "started") return true;
+							// Keep a terminal only when its exact start is already visible. A
+							// queued or pending start is cancelled above and cannot retain a
+							// terminal merely because its owner record has not been swept yet.
+							const key = `${toolActivity.sessionId}:tool:${toolActivity.toolCallId}`;
+							const owner = this.toolActivityOwners.get(key);
+							return !this.liveMessages.has(key) || owner?.session !== toolActivity.session;
+						});
 						for (const item of removedTools) {
 							const toolActivity = item.payload.toolActivity;
 							if (!toolActivity) continue;
@@ -8091,7 +9118,6 @@ export class TelegramNotificationDaemon {
 					// future starts are rejected immediately, queued starts are removed,
 					// and any already-granted Bot API effect settles before the off
 					// acknowledgement. Visible starts may still receive their terminal edit.
-					await this.flushChain;
 				}
 				await reply(`${label}: ${desired ? "on" : "off"}`);
 				return;
@@ -8582,12 +9608,10 @@ export class TelegramNotificationDaemon {
 			while (this.running) {
 				if (await this.controlStopRequested()) break;
 				if (
-					!(await renewDaemonHeartbeat({
+					!(await renewOwnerHeartbeatSidecar({
 						settings: this.opts.settings,
 						ownerId: this.opts.ownerId,
 						acquisitionId: this.opts.ownerId,
-						tokenFingerprint: tokenFingerprint(this.opts.botToken),
-						chatId: this.opts.chatId,
 						fs: this.fsImpl,
 						now: this.opts.now,
 						pid: this.opts.pid ?? process.pid,
@@ -8629,6 +9653,11 @@ export class TelegramNotificationDaemon {
 				await this.runtime.sleep(10);
 			}
 		} finally {
+			this.running = false;
+			this.runtime.stop();
+			this.stopOwnershipHeartbeatTimer();
+			const heartbeatJoined = await this.runtime.joinExclusive("telegram-owner-heartbeat", BTW_SHUTDOWN_JOIN_MS);
+			if (!heartbeatJoined) logger.warn("heartbeat join timed out; retaining daemon ownership (release aborted)");
 			// A contender must not mutate durable owner state while unwinding startup.
 			if (ownershipProved) {
 				let toolShutdownError: unknown;
@@ -8644,8 +9673,6 @@ export class TelegramNotificationDaemon {
 					if (toolShutdownError) throw toolShutdownError;
 					await this.#drainBtwTurns();
 					await this.toolTerminalizationChain;
-					this.runtime.stop();
-					this.stopOwnershipHeartbeatTimer();
 					this.stopFlushTimer();
 					this.stopScanTimer();
 					this.stopTypingTimer();
@@ -8670,7 +9697,7 @@ export class TelegramNotificationDaemon {
 					deadline.promise,
 				]);
 				clearTimeout(deadlineTimer);
-				const quiesced = completed && (await this.effects.join(BTW_SHUTDOWN_JOIN_MS));
+				const quiesced = completed && heartbeatJoined && (await this.effects.join(BTW_SHUTDOWN_JOIN_MS));
 				if (!quiesced || !persisted) {
 					logger.warn("notifications: shutdown was not durably quiesced; retaining daemon ownership");
 				} else {