@gajae-code/coding-agent 0.11.4 → 0.11.5

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