@gajae-code/coding-agent 0.11.4 → 0.11.6

package/src/runtime-mcp/oauth-discovery.ts

@@ -4,6 +4,8 @@
  * Automatically detects OAuth requirements from MCP server responses
  * and extracts authentication endpoints.
  */
+import type { AddressResolver, PublicUrlAccepted } from "../web/insane/url-guard";
+import { validatePublicHttpUrl } from "../web/insane/url-guard";
 
 export interface OAuthEndpoints {
 	authorizationUrl: string;
@@ -20,6 +22,16 @@ export interface AuthDetectionResult {
 	message?: string;
 }
 
+interface OAuthDiscoveryOptions {
+	fetch?: (input: string | URL | Request, init?: BunFetchRequestInit) => Promise<Response>;
+	resolver?: AddressResolver;
+	maxRequests?: number;
+	maxNodes?: number;
+	maxRedirects?: number;
+	timeoutMs?: number;
+	signal?: AbortSignal;
+}
+
 function parseMcpAuthServerUrl(errorMessage: string): string | undefined {
 	const match = errorMessage.match(/Mcp-Auth-Server:\s*([^;\]\s]+)/i);
 	if (!match?.[1]) return undefined;
@@ -194,17 +206,11 @@ export function analyzeAuthError(error: Error): AuthDetectionResult {
 		return { requiresAuth: false };
 	}
 
-	const authServerUrl = extractMcpAuthServerUrl(error);
-
-	// Try to extract OAuth endpoints
-	const oauth = extractOAuthEndpoints(error);
-
-	if (oauth) {
+	// Error text is useful for classification, but is not trusted discovery authority.
+	if (extractOAuthEndpoints(error) || extractMcpAuthServerUrl(error)) {
 		return {
 			requiresAuth: true,
 			authType: "oauth",
-			oauth,
-			authServerUrl,
 			message: "Server requires OAuth authentication. Launching authorization flow...",
 		};
 	}
@@ -220,7 +226,6 @@ export function analyzeAuthError(error: Error): AuthDetectionResult {
 		return {
 			requiresAuth: true,
 			authType: "apikey",
-			authServerUrl,
 			message: "Server requires API key authentication.",
 		};
 	}
@@ -229,7 +234,6 @@ export function analyzeAuthError(error: Error): AuthDetectionResult {
 	return {
 		requiresAuth: true,
 		authType: "unknown",
-		authServerUrl,
 		message: "Server requires authentication but type could not be determined.",
 	};
 }
@@ -241,6 +245,7 @@ export function analyzeAuthError(error: Error): AuthDetectionResult {
 export async function discoverOAuthEndpoints(
 	serverUrl: string,
 	authServerUrl?: string,
+	options: OAuthDiscoveryOptions = {},
 ): Promise<OAuthEndpoints | null> {
 	const wellKnownPaths = [
 		"/.well-known/oauth-authorization-server",
@@ -250,8 +255,82 @@ export async function discoverOAuthEndpoints(
 		"/.mcp/auth",
 		"/authorize", // Some MCP servers expose OAuth config here
 	];
-	const urlsToQuery = [authServerUrl, serverUrl].filter((value): value is string => Boolean(value));
-	const visitedAuthServers = new Set<string>();
+	const fetcher = options.fetch ?? globalThis.fetch;
+	const maxRequests = options.maxRequests ?? 32;
+	const maxNodes = options.maxNodes ?? 8;
+	const maxRedirects = options.maxRedirects ?? 3;
+	const timeoutSignal = AbortSignal.timeout(options.timeoutMs ?? 10_000);
+	const signal = options.signal ? AbortSignal.any([options.signal, timeoutSignal]) : timeoutSignal;
+	const { promise: aborted, resolve: resolveAbort } = Promise.withResolvers<null>();
+	if (signal.aborted) resolveAbort(null);
+	else signal.addEventListener("abort", () => resolveAbort(null), { once: true });
+	const queue: string[] = [];
+	const queued = new Set<string>();
+	const visited = new Set<string>();
+	let requests = 0;
+
+	const canonicalUrl = (raw: string): string | null => {
+		try {
+			const url = new URL(raw);
+			url.hash = "";
+			return url.toString();
+		} catch {
+			return null;
+		}
+	};
+
+	const validateUrl = async (raw: string): Promise<PublicUrlAccepted | null> => {
+		const canonical = canonicalUrl(raw);
+		if (!canonical || signal.aborted) return null;
+		const result = await Promise.race([validatePublicHttpUrl(canonical, { resolver: options.resolver }), aborted]);
+		if (!result) return null;
+		return result.ok && !signal.aborted ? result : null;
+	};
+
+	const enqueue = async (raw: string): Promise<void> => {
+		const canonical = canonicalUrl(raw);
+		if (!canonical) return;
+		const authority = new URL(canonical).origin;
+		if (queued.has(authority) || visited.has(authority) || queued.size + visited.size >= maxNodes) return;
+		const accepted = await validateUrl(canonical);
+		if (!accepted) return;
+		queued.add(accepted.url.origin);
+		queue.push(accepted.url.origin);
+	};
+
+	const fetchMetadata = async (raw: string): Promise<Record<string, unknown> | null> => {
+		let current = raw;
+		for (let redirects = 0; redirects <= maxRedirects; redirects++) {
+			if (signal.aborted || requests >= maxRequests) return null;
+			const accepted = await validateUrl(current);
+			if (!accepted) return null;
+			const target = new URL(accepted.url);
+			const address = accepted.addresses[0];
+			target.hostname = address.includes(":") ? `[${address}]` : address;
+			requests++;
+			const response = await fetcher(target, {
+				method: "GET",
+				headers: { Accept: "application/json", Host: accepted.url.host },
+				redirect: "manual",
+				signal,
+				tls: accepted.url.protocol === "https:" ? { serverName: accepted.url.hostname } : undefined,
+			});
+			if ([301, 302, 303, 307, 308].includes(response.status)) {
+				const location = response.headers.get("Location");
+				if (!location || redirects === maxRedirects) return null;
+				current = new URL(location, accepted.url).toString();
+				continue;
+			}
+			if (!response.ok) return null;
+			return (await Promise.race([response.json(), aborted])) as Record<string, unknown> | null;
+		}
+		return null;
+	};
+
+	const server = await validateUrl(serverUrl);
+	if (!server) return null;
+	await enqueue(server.url.toString());
+	if (authServerUrl) await enqueue(authServerUrl);
 
 	const findEndpoints = (metadata: Record<string, unknown>): OAuthEndpoints | null => {
 		if (metadata.authorization_endpoint && metadata.token_endpoint) {
@@ -310,32 +389,43 @@ export async function discoverOAuthEndpoints(
 		return null;
 	};
 
-	for (const baseUrl of urlsToQuery) {
-		visitedAuthServers.add(baseUrl);
+	while (queue.length > 0 && !signal.aborted && requests < maxRequests) {
+		const baseUrl = queue.shift()!;
+		queued.delete(baseUrl);
+		if (visited.has(baseUrl)) continue;
+		visited.add(baseUrl);
 		for (const path of wellKnownPaths) {
 			try {
 				const url = new URL(path, baseUrl);
-				const response = await fetch(url.toString(), {
-					method: "GET",
-					headers: { Accept: "application/json" },
-				});
+				const metadata = await fetchMetadata(url.toString());
 
-				if (response.ok) {
-					const metadata = (await response.json()) as Record<string, unknown>;
+				if (metadata) {
 					const endpoints = findEndpoints(metadata);
-					if (endpoints) return endpoints;
+					if (endpoints) {
+						const issuer = typeof metadata.issuer === "string" ? canonicalUrl(metadata.issuer) : null;
+						const issuerBound = issuer === canonicalUrl(baseUrl);
+						const authorization = await validateUrl(endpoints.authorizationUrl);
+						const token = await validateUrl(endpoints.tokenUrl);
+						const legacySameOrigin =
+							!issuer && authorization?.url.origin === baseUrl && token?.url.origin === baseUrl;
+						if ((issuerBound || legacySameOrigin) && authorization && token) {
+							return {
+								...endpoints,
+								authorizationUrl: authorization.url.toString(),
+								tokenUrl: token.url.toString(),
+							};
+						}
+					}
 
 					if (path === "/.well-known/oauth-protected-resource") {
+						const resource = typeof metadata.resource === "string" ? canonicalUrl(metadata.resource) : null;
+						if (resource !== canonicalUrl(server.url.toString())) continue;
 						const authServers = Array.isArray(metadata.authorization_servers)
 							? metadata.authorization_servers.filter((entry): entry is string => typeof entry === "string")
 							: [];
 
 						for (const discoveredAuthServer of authServers) {
-							if (visitedAuthServers.has(discoveredAuthServer)) {
-								continue;
-							}
-							const discovered = await discoverOAuthEndpoints(serverUrl, discoveredAuthServer);
-							if (discovered) return discovered;
+							await enqueue(discoveredAuthServer);
 						}
 					}
 				}

package/src/sdk/broker/session-index.ts

@@ -192,7 +192,14 @@ function alive(pid: number): boolean {
 		return (e as NodeJS.ErrnoException).code === "EPERM";
 	}
 }
+
+interface SessionIndexOpenGroup {
+	promise: Promise<void>;
+	closed: boolean;
+}
 export class SessionIndex {
+	static #operations = new Map<string, Promise<void>>();
+	static #openGroups = new Map<string, SessionIndexOpenGroup>();
 	#agentDir: string;
 	#events: SessionIndexEvent[] = [];
 	#warnings: string[] = [];
@@ -201,13 +208,45 @@ export class SessionIndex {
 	constructor(agentDir: string) {
 		this.#agentDir = agentDir;
 	}
+	static #enqueue<T>(indexPath: string, operation: () => Promise<T>): Promise<T> {
+		const previous = SessionIndex.#operations.get(indexPath) ?? Promise.resolve();
+		const promise = previous.catch(() => {}).then(operation);
+		const completion = promise.then(
+			() => {},
+			() => {},
+		);
+		SessionIndex.#operations.set(indexPath, completion);
+		void completion.then(() => {
+			if (SessionIndex.#operations.get(indexPath) === completion) SessionIndex.#operations.delete(indexPath);
+		});
+		return promise;
+	}
 	async open(): Promise<this> {
-		await fs.mkdir(dirFor(this.#agentDir), { recursive: true, mode: 0o700 });
-		await fs.chmod(dirFor(this.#agentDir), 0o700);
-		await withFileLock(logFor(this.#agentDir), () => this.replay());
+		const indexPath = path.resolve(logFor(this.#agentDir));
+		let group = SessionIndex.#openGroups.get(indexPath);
+		if (!group || group.closed) {
+			group = { promise: Promise.resolve(), closed: false };
+			SessionIndex.#openGroups.set(indexPath, group);
+			group.promise = SessionIndex.#enqueue(indexPath, () => this.#prepareOpenGroup(indexPath, group!));
+		}
+		await group.promise;
+		await SessionIndex.#enqueue(indexPath, () => withFileLock(logFor(this.#agentDir), () => this.#replayUnderLock()));
 		return this;
 	}
+	async #prepareOpenGroup(indexPath: string, group: SessionIndexOpenGroup): Promise<void> {
+		try {
+			await fs.mkdir(dirFor(this.#agentDir), { recursive: true, mode: 0o700 });
+			await fs.chmod(dirFor(this.#agentDir), 0o700);
+		} finally {
+			group.closed = true;
+			if (SessionIndex.#openGroups.get(indexPath) === group) SessionIndex.#openGroups.delete(indexPath);
+		}
+	}
 	async replay(): Promise<void> {
+		const indexPath = path.resolve(logFor(this.#agentDir));
+		await SessionIndex.#enqueue(indexPath, () => withFileLock(logFor(this.#agentDir), () => this.#replayUnderLock()));
+	}
+	async #replayUnderLock(): Promise<void> {
 		const scan = await this.#scan();
 		if (scan.diagnosis.status === "unsupported") throw scan.unsupportedError!;
 		this.#events = [...scan.snapshotEvents, ...scan.validLogEvents];
@@ -355,56 +394,63 @@ export class SessionIndex {
 		};
 	}
 	async diagnose(): Promise<SessionIndexDiagnosis> {
-		const exists = await Promise.all(
-			[snapshotFor(this.#agentDir), logFor(this.#agentDir)].map(async file => {
-				try {
-					await fs.stat(file);
-					return true;
-				} catch (error) {
-					if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
-					throw error;
-				}
-			}),
-		);
-		if (!exists.some(Boolean)) return { status: "healthy", validPrefixSeq: 0, snapshotSeq: 0 };
-		return await withFileLock(logFor(this.#agentDir), async () => (await this.#scan()).diagnosis);
+		const indexPath = path.resolve(logFor(this.#agentDir));
+		return await SessionIndex.#enqueue(indexPath, async () => {
+			const exists = await Promise.all(
+				[snapshotFor(this.#agentDir), logFor(this.#agentDir)].map(async file => {
+					try {
+						await fs.stat(file);
+						return true;
+					} catch (error) {
+						if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+						throw error;
+					}
+				}),
+			);
+			if (!exists.some(Boolean)) return { status: "healthy", validPrefixSeq: 0, snapshotSeq: 0 };
+			return await withFileLock(logFor(this.#agentDir), async () => (await this.#scan()).diagnosis);
+		});
 	}
 	async repair(): Promise<SessionIndexRepairResult> {
-		await fs.mkdir(dirFor(this.#agentDir), { recursive: true, mode: 0o700 });
-		return await withFileLock(logFor(this.#agentDir), async () => {
-			const scan = await this.#scan();
-			if (scan.diagnosis.status === "unsupported") return { ...scan.diagnosis, repaired: false };
-			if (scan.diagnosis.status === "healthy") return { ...scan.diagnosis, repaired: false };
-			const quarantineBase = path.join(dirFor(this.#agentDir), "quarantine");
-			await fs.mkdir(quarantineBase, { recursive: true, mode: 0o700 });
-			await syncDirectory(quarantineBase);
-			const quarantinePath = path.join(quarantineBase, `repair-${Date.now()}-${process.pid}-${randomUUID()}`);
-			await fs.mkdir(quarantinePath, { mode: 0o700 });
-			await syncDirectory(quarantinePath);
-			if (scan.snapshotContents)
-				await writeAndSync(path.join(quarantinePath, "index.snapshot.json"), scan.snapshotContents);
-			if (scan.logContents) await writeAndSync(path.join(quarantinePath, "index.jsonl"), scan.logContents);
-			await syncDirectory(path.join(quarantinePath, "index.jsonl"));
-			const snapshot = JSON.stringify({
-				version: SESSION_INDEX_SNAPSHOT_VERSION,
-				indexSeq: scan.snapshotEvents.at(-1)?.indexSeq ?? 0,
-				events: scan.snapshotEvents,
+		const indexPath = path.resolve(logFor(this.#agentDir));
+		return await SessionIndex.#enqueue(indexPath, async () => {
+			await fs.mkdir(dirFor(this.#agentDir), { recursive: true, mode: 0o700 });
+			return await withFileLock(logFor(this.#agentDir), async () => {
+				const scan = await this.#scan();
+				if (scan.diagnosis.status === "unsupported") return { ...scan.diagnosis, repaired: false };
+				if (scan.diagnosis.status === "healthy") return { ...scan.diagnosis, repaired: false };
+				const quarantineBase = path.join(dirFor(this.#agentDir), "quarantine");
+				await fs.mkdir(quarantineBase, { recursive: true, mode: 0o700 });
+				await syncDirectory(quarantineBase);
+				const quarantinePath = path.join(quarantineBase, `repair-${Date.now()}-${process.pid}-${randomUUID()}`);
+				await fs.mkdir(quarantinePath, { mode: 0o700 });
+				await syncDirectory(quarantinePath);
+				if (scan.snapshotContents)
+					await writeAndSync(path.join(quarantinePath, "index.snapshot.json"), scan.snapshotContents);
+				if (scan.logContents) await writeAndSync(path.join(quarantinePath, "index.jsonl"), scan.logContents);
+				await syncDirectory(path.join(quarantinePath, "index.jsonl"));
+				const events = [...scan.snapshotEvents, ...scan.validLogEvents];
+				const snapshot = JSON.stringify({
+					version: SESSION_INDEX_SNAPSHOT_VERSION,
+					indexSeq: scan.diagnosis.validPrefixSeq,
+					events,
+				});
+				const log = scan.validLogEvents.map(event => JSON.stringify(event)).join("\n");
+				await replaceAtomically(snapshotFor(this.#agentDir), snapshot);
+				await replaceAtomically(logFor(this.#agentDir), log ? `${log}\n` : "");
+				await this.#replayUnderLock();
+				return { ...scan.diagnosis, repaired: true, quarantinePath };
 			});
-			const log = scan.validLogEvents.map(event => JSON.stringify(event)).join("\n");
-			await replaceAtomically(snapshotFor(this.#agentDir), snapshot);
-			await replaceAtomically(logFor(this.#agentDir), log ? `${log}\n` : "");
-			await this.replay();
-			return { ...scan.diagnosis, repaired: true, quarantinePath };
 		});
 	}
-	async #tail(snapshotSeq = this.indexSeq, allowResync = true): Promise<void> {
+	async #tailUnderLock(snapshotSeq = this.indexSeq, allowResync = true): Promise<void> {
 		let data: Buffer;
 		try {
 			const handle = await fs.open(logFor(this.#agentDir), "r");
 			try {
 				const stat = await handle.stat();
 				if (stat.size < this.#logOffset) {
-					if (allowResync) await this.replay();
+					if (allowResync) await this.#replayUnderLock();
 					else this.#warn("Session index log was truncated");
 					return;
 				}
@@ -442,7 +488,7 @@ export class SessionIndex {
 		if (corrupt) {
 			this.#corruptSuffix = true;
 			this.#warn("Corrupt session index entry; replay truncated");
-			if (allowResync) await this.replay();
+			if (allowResync) await this.#replayUnderLock();
 		}
 	}
 	#warn(message: string): void {
@@ -450,7 +496,13 @@ export class SessionIndex {
 	}
 
 	async refresh(): Promise<void> {
-		await this.#tail();
+		const indexPath = path.resolve(logFor(this.#agentDir));
+		await SessionIndex.#enqueue(indexPath, () =>
+			withFileLock(logFor(this.#agentDir), () => this.#refreshUnderLock()),
+		);
+	}
+	async #refreshUnderLock(): Promise<void> {
+		await this.#tailUnderLock();
 	}
 	get indexSeq(): number {
 		return this.#events.at(-1)?.indexSeq ?? 0;
@@ -459,31 +511,37 @@ export class SessionIndex {
 		input: Omit<SessionIndexEvent, "version" | "indexSeq" | "checksum" | "ts"> &
 			Partial<Pick<SessionIndexEvent, "ts">>,
 	): Promise<SessionIndexEvent> {
-		await fs.mkdir(dirFor(this.#agentDir), { recursive: true, mode: 0o700 });
-		return withFileLock(logFor(this.#agentDir), async () => {
-			await this.replay();
-			if (this.#corruptSuffix)
-				throw new Error(
-					"Cannot append to corrupt session index log; run `gjc gc --repair-session-index` to quarantine evidence and retain the valid prefix",
-				);
-			const unsigned: Omit<SessionIndexEvent, "checksum"> = {
-				...input,
-				version: SDK_STATE_VERSION,
-				indexSeq: this.indexSeq + 1,
-				ts: input.ts ?? Date.now(),
-			};
-			const event: SessionIndexEvent = { ...unsigned, checksum: sessionIndexChecksum(unsigned) };
-			await appendSync(logFor(this.#agentDir), JSON.stringify(event));
-			await this.refresh();
-			if ((await fs.stat(logFor(this.#agentDir))).size >= ROTATE_BYTES) await this.#rotate();
-			return event;
+		const indexPath = path.resolve(logFor(this.#agentDir));
+		return await SessionIndex.#enqueue(indexPath, async () => {
+			await fs.mkdir(dirFor(this.#agentDir), { recursive: true, mode: 0o700 });
+			return await withFileLock(logFor(this.#agentDir), async () => {
+				await this.#replayUnderLock();
+				if (this.#corruptSuffix)
+					throw new Error(
+						"Cannot append to corrupt session index log; run `gjc gc --repair-session-index` to quarantine evidence and retain the valid prefix",
+					);
+				const unsigned: Omit<SessionIndexEvent, "checksum"> = {
+					...input,
+					version: SDK_STATE_VERSION,
+					indexSeq: this.indexSeq + 1,
+					ts: input.ts ?? Date.now(),
+				};
+				const event: SessionIndexEvent = { ...unsigned, checksum: sessionIndexChecksum(unsigned) };
+				await appendSync(logFor(this.#agentDir), JSON.stringify(event));
+				await this.#refreshUnderLock();
+				if ((await fs.stat(logFor(this.#agentDir))).size >= ROTATE_BYTES) await this.#rotate();
+				return event;
+			});
 		});
 	}
 	async snapshot(): Promise<void> {
-		await withFileLock(logFor(this.#agentDir), () => this.#snapshotUnderLock());
+		const indexPath = path.resolve(logFor(this.#agentDir));
+		await SessionIndex.#enqueue(indexPath, () =>
+			withFileLock(logFor(this.#agentDir), () => this.#snapshotUnderLock()),
+		);
 	}
 	async #snapshotUnderLock(): Promise<void> {
-		await this.replay();
+		await this.#replayUnderLock();
 		const file = snapshotFor(this.#agentDir);
 		let current: unknown;
 		try {

package/src/sdk/bus/chat-daemon-cli.ts

@@ -26,11 +26,13 @@ export interface ChatDaemonRuntimeHandle {
 export interface RunChatDaemonInternalDeps {
 	processPid?: number;
 	pidAlive?: (pid: number) => boolean;
+	pidIncarnation?: (pid: number) => string | undefined;
 	createRuntime?: (input: {
 		kind: ChatDaemonKind;
 		agentDir: string;
 		config: ChatDaemonConfig;
 	}) => Promise<ChatDaemonRuntimeHandle> | ChatDaemonRuntimeHandle;
+	renewHeartbeat?: (input: Parameters<typeof renewChatDaemonHeartbeat>[0]) => Promise<boolean>;
 	setInterval?: typeof setInterval;
 	clearInterval?: typeof clearInterval;
 }
@@ -65,8 +67,10 @@ async function loadConfig(agentDir: string, kind: ChatDaemonKind): Promise<ChatD
 				idleTimeoutMs: 60_000,
 				rich: { enabled: true },
 				richDraft: { enabled: false },
+				toolActivity: { enabled: true },
 				topics: { nameTemplate: undefined },
 				btw: { enabled: true },
+				streaming: { enabled: true },
 			})
 		) {
 			throw new Error("Discord notifications are enabled but configuration is incomplete");
@@ -98,8 +102,10 @@ async function loadConfig(agentDir: string, kind: ChatDaemonKind): Promise<ChatD
 			idleTimeoutMs: 60_000,
 			rich: { enabled: true },
 			richDraft: { enabled: false },
+			toolActivity: { enabled: true },
 			topics: { nameTemplate: undefined },
 			btw: { enabled: true },
+			streaming: { enabled: true },
 		})
 	) {
 		throw new Error("Slack notifications are enabled but configuration is incomplete");
@@ -160,10 +166,19 @@ export async function runChatDaemonInternal(
 	if (!ownerId) throw new Error("missing --owner-id");
 	const pid = ownerPid(ownerId);
 	if (pid !== undefined && !(deps.pidAlive ?? defaultPidAlive)(pid)) return;
+	const daemonPid = deps.processPid ?? process.pid;
 	const config = await loadConfig(agentDir, kind);
 	if (!config) return;
 	if (
-		!(await acquireChatDaemonOwnership({ agentDir, kind, ownerId, pid: deps.processPid, identity: config.identity }))
+		!(await acquireChatDaemonOwnership({
+			agentDir,
+			kind,
+			ownerId,
+			pid: daemonPid,
+			identity: config.identity,
+			pidAlive: deps.pidAlive,
+			pidIncarnation: deps.pidIncarnation,
+		}))
 	)
 		return;
 
@@ -171,30 +186,60 @@ export async function runChatDaemonInternal(
 	let runtime: ChatDaemonRuntimeHandle | undefined;
 	let interval: ReturnType<typeof setInterval> | undefined;
 	let stopping = false;
+	let terminalError: unknown;
+	let runtimeStop: Promise<void> | undefined;
+	const stopRuntime = (): Promise<void> => {
+		runtimeStop ??= runtime?.stop() ?? Promise.resolve();
+		return runtimeStop;
+	};
 	const stop = (): void => {
 		stopping = true;
+		void stopRuntime().catch(error => {
+			terminalError ??= error;
+		});
 	};
 	try {
 		incarnation = (await readChatDaemonState(agentDir, kind))?.incarnation;
 		if (!incarnation) throw new Error("chat daemon ownership state is missing an incarnation");
 		runtime = await (deps.createRuntime?.({ kind, agentDir, config }) ?? defaultRuntime({ kind, agentDir, config }));
-		const renewHeartbeat = async (): Promise<void> => {
-			await renewChatDaemonHeartbeat({
+		const activeRuntime = runtime;
+		const renewHeartbeat = async (): Promise<boolean> =>
+			await (deps.renewHeartbeat ?? renewChatDaemonHeartbeat)({
 				agentDir,
 				kind,
 				ownerId,
-				pid: deps.processPid,
+				pid: daemonPid,
 				incarnation,
-				transportHealthy: runtime?.transportHealthy?.() ?? true,
+				transportHealthy: activeRuntime.transportHealthy?.() ?? true,
+				pidAlive: deps.pidAlive,
+				pidIncarnation: deps.pidIncarnation,
 			});
+		const terminateForLostOwnership = async (): Promise<void> => {
+			stopping = true;
+			await stopRuntime();
 		};
 		process.once("SIGTERM", stop);
 		process.once("SIGINT", stop);
+		if (!(await renewHeartbeat())) {
+			await terminateForLostOwnership();
+			return;
+		}
+		await runtime.start();
 		interval = (deps.setInterval ?? setInterval)(() => {
-			void renewHeartbeat();
+			void (async () => {
+				try {
+					if (!(await renewHeartbeat())) await terminateForLostOwnership();
+				} catch (error) {
+					terminalError ??= error;
+					stopping = true;
+					try {
+						await stopRuntime();
+					} catch (stopError) {
+						terminalError ??= stopError;
+					}
+				}
+			})();
 		}, 5_000);
-		await runtime.start();
-		await renewHeartbeat();
 		while (!stopping) {
 			const request = await readChatDaemonControlRequest(agentDir, kind);
 			if (request?.ownerId === ownerId && request.incarnation === incarnation) {
@@ -208,9 +253,26 @@ export async function runChatDaemonInternal(
 		process.off("SIGTERM", stop);
 		process.off("SIGINT", stop);
 		try {
-			await runtime?.stop();
+			await stopRuntime();
+		} catch (error) {
+			terminalError ??= error;
 		} finally {
-			await releaseChatDaemonOwnership({ agentDir, kind, ownerId, pid: deps.processPid, incarnation });
+			if (incarnation !== undefined) {
+				try {
+					await releaseChatDaemonOwnership({
+						agentDir,
+						kind,
+						ownerId,
+						pid: daemonPid,
+						incarnation,
+						pidAlive: deps.pidAlive,
+						pidIncarnation: deps.pidIncarnation,
+					});
+				} catch (error) {
+					terminalError ??= error;
+				}
+			}
 		}
 	}
+	if (terminalError !== undefined) throw terminalError;
 }