@gajae-code/coding-agent 0.11.3 → 0.11.5

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

@@ -1,4 +1,4 @@
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import { withFileLock } from "../../config/file-lock";
@@ -48,6 +48,27 @@ export interface SessionList {
 	sessions: IndexedSession[];
 	warnings: string[];
 }
+
+export interface SessionIndexDiagnosis {
+	status: "healthy" | "corrupt" | "unsupported";
+	validPrefixSeq: number;
+	snapshotSeq: number;
+	reason?: string;
+}
+
+export interface SessionIndexRepairResult extends SessionIndexDiagnosis {
+	repaired: boolean;
+	quarantinePath?: string;
+}
+
+interface SessionIndexScan {
+	diagnosis: SessionIndexDiagnosis;
+	snapshotEvents: SessionIndexEvent[];
+	validLogEvents: SessionIndexEvent[];
+	snapshotContents: Buffer | undefined;
+	logContents: Buffer | undefined;
+	unsupportedError?: UnsupportedStateVersionError;
+}
 const canonical = (event: Omit<SessionIndexEvent, "checksum">) => JSON.stringify(event);
 export const sessionIndexChecksum = (event: Omit<SessionIndexEvent, "checksum">) =>
 	createHash("sha256").update(canonical(event)).digest("hex");
@@ -142,6 +163,27 @@ async function syncDirectory(file: string): Promise<void> {
 	}
 }
 
+async function writeAndSync(file: string, contents: Buffer | string): Promise<void> {
+	const handle = await fs.open(file, "w", 0o600);
+	try {
+		await handle.writeFile(contents);
+		await handle.sync();
+	} finally {
+		await handle.close();
+	}
+}
+
+async function replaceAtomically(file: string, contents: Buffer | string): Promise<void> {
+	const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		await writeAndSync(temporary, contents);
+		await fs.rename(temporary, file);
+		await syncDirectory(file);
+	} finally {
+		await fs.rm(temporary, { force: true });
+	}
+}
+
 function alive(pid: number): boolean {
 	try {
 		process.kill(pid, 0);
@@ -150,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[] = [];
@@ -159,42 +208,249 @@ 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> {
-		this.#events = [];
+		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];
 		this.#warnings = [];
-		this.#logOffset = 0;
-		this.#corruptSuffix = false;
+		this.#logOffset = scan.logContents?.length ?? 0;
+		this.#corruptSuffix = scan.diagnosis.status === "corrupt";
+		if (scan.diagnosis.reason === "invalid snapshot") this.#warnings.push("Invalid session index snapshot");
+		if (this.#corruptSuffix) this.#warnings.push("Corrupt session index entry; replay truncated");
+	}
+	async #scan(): Promise<SessionIndexScan> {
+		let snapshotContents: Buffer | undefined;
+		let logContents: Buffer | undefined;
+		let snapshotEvents: SessionIndexEvent[] = [];
 		let snapshotSeq = 0;
+		let trustedSnapshotSeq = 0;
+		let invalidSnapshot = false;
+		let unsupportedError: UnsupportedStateVersionError | undefined;
 		try {
-			const snapshot = JSON.parse(await fs.readFile(snapshotFor(this.#agentDir), "utf8")) as {
+			snapshotContents = await fs.readFile(snapshotFor(this.#agentDir));
+			const snapshot = JSON.parse(snapshotContents.toString("utf8")) as {
 				version?: number;
-				events?: SessionIndexEvent[];
-				indexSeq?: number;
+				indexSeq?: unknown;
+				events?: unknown;
 			};
+			if (typeof snapshot.indexSeq === "number" && Number.isSafeInteger(snapshot.indexSeq) && snapshot.indexSeq >= 0)
+				snapshotSeq = snapshot.indexSeq;
 			assertSupportedSnapshotVersion(snapshotFor(this.#agentDir), snapshot);
-			if (!isValidSnapshot(snapshot)) throw new Error("invalid snapshot");
-			this.#events = snapshot.events;
-			snapshotSeq = snapshot.indexSeq;
-		} catch (e) {
-			if (e instanceof UnsupportedStateVersionError) throw e;
-			if ((e as NodeJS.ErrnoException).code !== "ENOENT") this.#warnings.push("Invalid session index snapshot");
+			const supportedEvents: SessionIndexEvent[] = [];
+			if (Array.isArray(snapshot.events)) {
+				try {
+					for (const event of snapshot.events) {
+						assertSupportedStateVersion(snapshotFor(this.#agentDir), event);
+						supportedEvents.push(event as SessionIndexEvent);
+					}
+				} catch (error) {
+					if (!(error instanceof UnsupportedStateVersionError)) throw error;
+					unsupportedError = error;
+					snapshotEvents = supportedEvents;
+				}
+			}
+			if (!unsupportedError) {
+				if (!isValidSnapshot(snapshot)) invalidSnapshot = true;
+				else {
+					snapshotEvents = snapshot.events;
+					trustedSnapshotSeq = snapshot.indexSeq;
+				}
+			}
+		} catch (error) {
+			if (error instanceof UnsupportedStateVersionError) unsupportedError = error;
+			else if ((error as NodeJS.ErrnoException).code !== "ENOENT") invalidSnapshot = true;
+		}
+		try {
+			logContents = await fs.readFile(logFor(this.#agentDir));
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+		}
+		const validLogEvents: SessionIndexEvent[] = [];
+		let corrupt = invalidSnapshot;
+		let logCorrupt = false;
+		let tailStarted = false;
+		let historicalLast: number | undefined;
+		let expected = trustedSnapshotSeq + 1;
+		if (logContents) {
+			const text = logContents.toString("utf8");
+			const lines = text.split("\n");
+			const terminal = lines.pop();
+			for (const line of lines) {
+				if (!line) continue;
+				try {
+					const event = JSON.parse(line) as SessionIndexEvent;
+					assertSupportedStateVersion(logFor(this.#agentDir), event);
+					const { checksum, ...unsigned } = event;
+					if (checksum !== sessionIndexChecksum(unsigned)) {
+						corrupt = true;
+						logCorrupt = true;
+						continue;
+					}
+					if (!tailStarted && !invalidSnapshot && event.indexSeq <= trustedSnapshotSeq) {
+						if (
+							!Number.isSafeInteger(event.indexSeq) ||
+							event.indexSeq <= 0 ||
+							(historicalLast !== undefined && event.indexSeq !== historicalLast + 1)
+						) {
+							corrupt = true;
+							logCorrupt = true;
+						} else {
+							historicalLast = event.indexSeq;
+						}
+						continue;
+					}
+					tailStarted = true;
+					if (historicalLast !== undefined && historicalLast !== trustedSnapshotSeq) {
+						corrupt = true;
+						logCorrupt = true;
+					}
+					if (event.indexSeq !== expected) {
+						corrupt = true;
+						logCorrupt = true;
+					} else if (!logCorrupt) {
+						validLogEvents.push(event);
+						expected++;
+					}
+				} catch (error) {
+					if (error instanceof UnsupportedStateVersionError) {
+						const verifiedSnapshotPrefix = snapshotEvents.at(-1)?.indexSeq ?? trustedSnapshotSeq;
+						const validPrefixSeq = validLogEvents.at(-1)?.indexSeq ?? verifiedSnapshotPrefix;
+						return {
+							diagnosis: { status: "unsupported", validPrefixSeq, snapshotSeq, reason: error.message },
+							snapshotEvents,
+							validLogEvents,
+							snapshotContents,
+							logContents,
+							unsupportedError: error,
+						};
+					}
+					corrupt = true;
+					logCorrupt = true;
+				}
+			}
+			if (historicalLast !== undefined && !tailStarted && historicalLast !== trustedSnapshotSeq) {
+				corrupt = true;
+				logCorrupt = true;
+			}
+			if (terminal !== "") {
+				corrupt = true;
+				logCorrupt = true;
+			}
 		}
-		await this.#tail(snapshotSeq, false);
+		const verifiedSnapshotPrefix = snapshotEvents.at(-1)?.indexSeq ?? trustedSnapshotSeq;
+		const validPrefixSeq = validLogEvents.at(-1)?.indexSeq ?? verifiedSnapshotPrefix;
+		return {
+			diagnosis: {
+				status: unsupportedError ? "unsupported" : corrupt ? "corrupt" : "healthy",
+				validPrefixSeq,
+				snapshotSeq,
+				reason:
+					unsupportedError?.message ??
+					(invalidSnapshot ? "invalid snapshot" : corrupt ? "invalid log sequence" : undefined),
+			},
+			snapshotEvents,
+			validLogEvents,
+			snapshotContents,
+			logContents,
+			unsupportedError,
+		};
 	}
-	async #tail(snapshotSeq = this.indexSeq, allowResync = true): Promise<void> {
+	async diagnose(): Promise<SessionIndexDiagnosis> {
+		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> {
+		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 };
+			});
+		});
+	}
+	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;
 				}
@@ -232,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 {
@@ -240,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;
@@ -249,28 +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");
-			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/broker/state-version.ts

@@ -13,8 +13,11 @@ export class UnsupportedStateVersionError extends Error {
 	constructor(
 		readonly file: string,
 		readonly version: number,
+		readonly maximumSupportedVersion = SDK_STATE_VERSION,
 	) {
-		super(`Unsupported SDK state version ${version} in ${file}; maximum supported version is ${SDK_STATE_VERSION}.`);
+		super(
+			`Unsupported SDK state version ${version} in ${file}; maximum supported version is ${maximumSupportedVersion}.`,
+		);
 		this.name = "UnsupportedStateVersionError";
 	}
 }
@@ -38,7 +41,7 @@ export function assertSupportedSnapshotVersion(file: string, value: unknown): vo
 	const record = value as { version?: unknown; stateVersion?: unknown };
 	for (const version of [record.version, record.stateVersion]) {
 		if (typeof version === "number" && Number.isFinite(version) && version > SESSION_INDEX_SNAPSHOT_VERSION) {
-			throw new UnsupportedStateVersionError(file, version);
+			throw new UnsupportedStateVersionError(file, version, SESSION_INDEX_SNAPSHOT_VERSION);
 		}
 	}
 }

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;
 }