@gajae-code/coding-agent 0.13.2 → 0.14.0

package/src/sdk/bus/config.ts

@@ -13,6 +13,19 @@ import { ConfigFile, type LoadResult } from "../../config/config-file";
  * site marks it, never by inheriting a marked ancestor's environment.
  */
 export const SPAWN_PROVENANCE_ENV = "GJC_SPAWNED_BY_SESSION";
+/**
+ * Telegram session eligibility: whether a session may own a forum topic and be
+ * admitted by the notification daemon.
+ *
+ * This follows the user's configuration, never how the session was launched.
+ * Gating it on coordinator/lifecycle provenance made every ordinary
+ * interactive session declare itself ineligible, and the daemon refuses an
+ * identity header that does so — so no notification was ever delivered even
+ * though the daemon looked healthy and attached.
+ */
+export function isTelegramSessionEligible(cfg: NotificationConfig): boolean {
+	return isProviderEffectivelyEnabled(cfg, "telegram") && isTelegramComplete(cfg);
+}
 
 export type TelegramActivationState = "inactive" | "blocked";
 export type TelegramActivationReason = "saved_inactive" | "identity_mismatch";

package/src/sdk/bus/conversation-store.ts

@@ -28,7 +28,6 @@ export interface ConversationStoreFs {
 	readFile(file: string, encoding: "utf8"): Promise<string>;
 	writeFile(file: string, data: string, options: { mode: number }): Promise<void>;
 	rename(from: string, to: string): Promise<void>;
-	link(from: string, to: string): Promise<void>;
 	unlink(file: string): Promise<void>;
 	open(file: string, flags: string): Promise<ConversationStoreFileHandle>;
 	stat?(file: string): Promise<{ mtimeMs: number }>;
@@ -47,22 +46,11 @@ export class ConversationLockTimeoutError extends Error {
 interface ConversationStoreLock {
 	pid: number;
 	incarnation: string;
-	isolateId?: string;
 	timestamp: number;
-	/** Uniquely identifies one acquire; lets a release prove it owns the lock file. */
-	nonce?: string;
 }
 
 const nodeFs: ConversationStoreFs = fs;
-/** Unique to this module evaluation, including one Bun worker isolate. */
-const processIsolateId = randomUUID();
-
-/**
- * Lock files this process currently holds or is acquiring, across every store.
- * The token lets a releasing predecessor preserve a successor's marker when
- * the same path has already been reacquired.
- */
-const heldLockFiles = new Map<string, Set<string>>();
+const UNPUBLISHED_LOCK_STALE_MS = 30_000;
 
 export function conversationStorePath(agentDir: string, kind: string, fileName = "conversations.json"): string {
 	return path.join(agentDir, "sdk", "daemons", kind, fileName);
@@ -226,220 +214,108 @@ export class ConversationStore<T extends ConversationRecord> {
 		const tail = previous.then(() => gate.promise);
 		this.#locks.set(this.#file, tail);
 		await previous;
-		const lockFile = `${this.#file}.lock`;
 		let fileLock: ConversationStoreFileHandle | undefined;
-		let lockToken: ConversationStoreLock | undefined;
 		try {
-			const acquired = await this.#acquireFileLock();
-			fileLock = acquired.handle;
-			lockToken = acquired.lock;
+			fileLock = await this.#acquireFileLock();
 			return await operation();
 		} finally {
 			try {
-				// A failed close must never skip the unlink: that would leak a
-				// well-formed lock whose pid is still alive and block every later
-				// waiter for the full timeout. The unlink is ownership-checked so
-				// it can only ever remove the lock this holder wrote.
-				if (fileLock) await fileLock.close().catch(() => undefined);
-				if (fileLock && lockToken) await this.#unlinkOwnedLock(lockFile, lockToken);
+				await closeConversationStoreFileLock(fileLock);
+				if (fileLock)
+					await this.#fs.unlink(`${this.#file}.lock`).catch(error => {
+						if (!isMissing(error)) throw error;
+					});
 			} finally {
-				if (lockToken) this.#releaseHeldLock(lockFile, lockToken);
 				gate.resolve();
 				if (this.#locks.get(this.#file) === tail) this.#locks.delete(this.#file);
 			}
 		}
 	}
 
-	#releaseHeldLock(lockFile: string, lock: ConversationStoreLock): void {
-		const tokens = heldLockFiles.get(lockFile);
-		if (!tokens) return;
-		tokens.delete(lock.nonce!);
-		if (tokens.size === 0) heldLockFiles.delete(lockFile);
-	}
-
-	async #unlinkOwnedLock(lockFile: string, expected: ConversationStoreLock): Promise<boolean> {
-		let parsed: unknown;
-		try {
-			parsed = JSON.parse(await this.#fs.readFile(lockFile, "utf8"));
-		} catch (error) {
-			if (isMissing(error)) return false;
-			return false; // unreadable: never remove a lock we cannot identify
-		}
-		if (
-			!isConversationStoreLock(parsed) ||
-			parsed.pid !== expected.pid ||
-			parsed.incarnation !== expected.incarnation ||
-			parsed.isolateId !== expected.isolateId ||
-			parsed.timestamp !== expected.timestamp ||
-			parsed.nonce !== expected.nonce
-		)
-			return false; // a successor holds the path now; leave it
-		try {
-			await this.#fs.unlink(lockFile);
-			return true;
-		} catch (error) {
-			if (isMissing(error)) return false;
-			throw error;
-		}
-	}
-
-	async #acquireFileLock(): Promise<{ handle: ConversationStoreFileHandle; lock: ConversationStoreLock }> {
+	async #acquireFileLock(): Promise<ConversationStoreFileHandle> {
 		const lockFile = `${this.#file}.lock`;
 		const deadline = Date.now() + this.#lockTimeoutMs;
 		await this.#fs.mkdir(this.#directory, { recursive: true, mode: 0o700 });
 		for (;;) {
 			try {
-				return await this.#createLockFile(lockFile);
+				const handle = await this.#fs.open(lockFile, "wx");
+				try {
+					const lock: ConversationStoreLock = {
+						pid: this.#pid,
+						incarnation: this.#pidIncarnation(this.#pid) ?? "unavailable",
+						timestamp: this.#clock(),
+					};
+					await handle.writeFile(`${JSON.stringify(lock)}\n`, "utf8");
+					await handle.sync();
+					return handle;
+				} catch (error) {
+					await handle.close().catch(() => undefined);
+					await this.#fs.unlink(lockFile).catch(() => undefined);
+					throw error;
+				}
 			} catch (error) {
 				if (!isAlreadyExists(error)) throw error;
 				if (await this.#reclaimStaleLock(lockFile)) continue;
-				if (await this.#reclaimSameProcessLeak(lockFile)) continue;
 				if (Date.now() >= deadline) throw new ConversationLockTimeoutError(lockFile, this.#lockTimeoutMs);
 				await this.#sleep(Math.min(10, Math.max(1, deadline - Date.now())));
 			}
 		}
 	}
 
-	/**
-	 * Removes a well-formed lock this process wrote but no longer holds. Healing
-	 * is serialized by its own ownership-tracked reclaim lock, so concurrent
-	 * waiters cannot delete a successor after the original leak is removed.
-	 */
-	async #reclaimSameProcessLeak(lockFile: string): Promise<boolean> {
-		const expected = await this.#readLock(lockFile);
-		if (
-			!expected ||
-			expected.pid !== this.#pid ||
-			expected.isolateId !== processIsolateId ||
-			heldLockFiles.has(lockFile)
-		)
-			return false;
-
-		const reclaimFile = `${lockFile}.reclaim`;
-		const reclaimLock = await this.#acquireReclaimLock(reclaimFile);
-		if (!reclaimLock) return false;
-		try {
-			if (expected.pid !== this.#pid || expected.isolateId !== processIsolateId || heldLockFiles.has(lockFile))
-				return false;
-			return await this.#unlinkOwnedLock(lockFile, expected);
-		} catch {
-			return false;
-		} finally {
-			await reclaimLock.handle.close().catch(() => undefined);
-			try {
-				await this.#unlinkOwnedLock(reclaimFile, reclaimLock.lock).catch(() => undefined);
-			} finally {
-				this.#releaseHeldLock(reclaimFile, reclaimLock.lock);
-			}
-		}
-	}
-
 	async #reclaimStaleLock(lockFile: string): Promise<boolean> {
 		if (!(await this.#isStaleLock(lockFile))) return false;
 		const reclaimFile = `${lockFile}.reclaim`;
 		const reclaimLock = await this.#acquireReclaimLock(reclaimFile);
 		if (!reclaimLock) return false;
 		try {
-			const staleLock = await this.#readLock(lockFile);
-			if (!staleLock || !(await this.#isStaleLock(lockFile))) return false;
-			return await this.#unlinkOwnedLock(lockFile, staleLock);
-		} catch {
-			return false;
+			if (!(await this.#isStaleLock(lockFile))) return false;
+			await this.#fs.unlink(lockFile).catch(() => undefined);
+			return true;
 		} finally {
-			await reclaimLock.handle.close().catch(() => undefined);
-			try {
-				await this.#unlinkOwnedLock(reclaimFile, reclaimLock.lock).catch(() => undefined);
-			} finally {
-				this.#releaseHeldLock(reclaimFile, reclaimLock.lock);
-			}
+			await reclaimLock.close().catch(() => undefined);
+			await this.#fs.unlink(reclaimFile).catch(() => undefined);
 		}
 	}
-
-	async #acquireReclaimLock(
-		reclaimFile: string,
-	): Promise<{ handle: ConversationStoreFileHandle; lock: ConversationStoreLock } | undefined> {
+	async #acquireReclaimLock(reclaimFile: string): Promise<ConversationStoreFileHandle | undefined> {
 		try {
 			return await this.#createLockFile(reclaimFile);
 		} catch (error) {
-			if (!isAlreadyExists(error)) return undefined;
-			if (await this.#reclaimStaleLock(reclaimFile)) {
-				try {
-					return await this.#createLockFile(reclaimFile);
-				} catch (retryError) {
-					if (isAlreadyExists(retryError)) return undefined;
-					throw retryError;
-				}
-			}
-			if (await this.#reclaimSameProcessLeak(reclaimFile)) {
-				try {
-					return await this.#createLockFile(reclaimFile);
-				} catch (retryError) {
-					if (isAlreadyExists(retryError)) return undefined;
-					throw retryError;
-				}
+			if (!isAlreadyExists(error) || !(await this.#isStaleLock(reclaimFile))) return undefined;
+			await this.#fs.unlink(reclaimFile).catch(() => undefined);
+			try {
+				return await this.#createLockFile(reclaimFile);
+			} catch (retryError) {
+				if (isAlreadyExists(retryError)) return undefined;
+				throw retryError;
 			}
-			return undefined;
 		}
 	}
-
-	async #createLockFile(
-		lockFile: string,
-	): Promise<{ handle: ConversationStoreFileHandle; lock: ConversationStoreLock }> {
-		const pendingFile = `${lockFile}.${this.#pid}.${randomUUID()}.pending`;
-		const handle = await this.#fs.open(pendingFile, "wx");
-		let lock: ConversationStoreLock | undefined;
-		let published = false;
+	async #createLockFile(lockFile: string): Promise<ConversationStoreFileHandle> {
+		const handle = await this.#fs.open(lockFile, "wx");
 		try {
-			lock = {
+			const lock: ConversationStoreLock = {
 				pid: this.#pid,
 				incarnation: this.#pidIncarnation(this.#pid) ?? "unavailable",
-				isolateId: processIsolateId,
 				timestamp: this.#clock(),
-				nonce: randomUUID(),
 			};
-			const heldTokens = heldLockFiles.get(lockFile) ?? new Set<string>();
-			heldTokens.add(lock.nonce!);
-			heldLockFiles.set(lockFile, heldTokens);
 			await handle.writeFile(`${JSON.stringify(lock)}\n`, "utf8");
 			await handle.sync();
-			await this.#fs.link(pendingFile, lockFile);
-			published = true;
-			await this.#fs.unlink(pendingFile);
-			return { handle, lock };
+			return handle;
 		} catch (error) {
-			try {
-				await handle.close().catch(() => undefined);
-				try {
-					if (published && lock) await this.#unlinkOwnedLock(lockFile, lock);
-				} finally {
-					await this.#fs.unlink(pendingFile).catch(() => undefined);
-				}
-			} finally {
-				if (lock) this.#releaseHeldLock(lockFile, lock);
-			}
+			await handle.close().catch(() => undefined);
+			await this.#fs.unlink(lockFile).catch(() => undefined);
 			throw error;
 		}
 	}
-
-	async #readLock(lockFile: string): Promise<ConversationStoreLock | undefined> {
-		try {
-			const parsed: unknown = JSON.parse(await this.#fs.readFile(lockFile, "utf8"));
-			return isConversationStoreLock(parsed) ? parsed : undefined;
-		} catch {
-			return undefined;
-		}
-	}
-
 	async #isStaleLock(lockFile: string): Promise<boolean> {
 		let parsed: unknown;
 		try {
 			parsed = JSON.parse(await this.#fs.readFile(lockFile, "utf8"));
-		} catch {
-			// An unreadable legacy marker may still have an open creator. It is
-			// never safe to reclaim it based on age alone.
-			return false;
+		} catch (error) {
+			if (isMissing(error)) return true;
+			return await this.#isExpiredUnpublishedLock(lockFile);
 		}
-		if (!isConversationStoreLock(parsed)) return false;
+		if (!isConversationStoreLock(parsed)) return await this.#isExpiredUnpublishedLock(lockFile);
 		const currentIncarnation = this.#pidIncarnation(parsed.pid);
 		return (
 			!this.#pidAlive(parsed.pid) ||
@@ -448,6 +324,10 @@ export class ConversationStore<T extends ConversationRecord> {
 					(currentIncarnation !== undefined && currentIncarnation !== parsed.incarnation)))
 		);
 	}
+	async #isExpiredUnpublishedLock(lockFile: string): Promise<boolean> {
+		const stat = this.#fs.stat ? await this.#fs.stat(lockFile).catch(() => undefined) : undefined;
+		return Boolean(stat && this.#clock() - stat.mtimeMs >= UNPUBLISHED_LOCK_STALE_MS);
+	}
 
 	async #readDocument(): Promise<ConversationStoreDocument<T>> {
 		try {
@@ -488,6 +368,15 @@ function isMissing(error: unknown): error is NodeJS.ErrnoException {
 	return isRecord(error) && error.code === "ENOENT";
 }
 
+async function closeConversationStoreFileLock(handle: ConversationStoreFileHandle | undefined): Promise<void> {
+	if (!handle) return;
+	// A failed close must never skip the unlink: that would leak a well-formed
+	// lock whose pid is still alive and block every later waiter. The unlink is
+	// ownership-checked by the pending-file model so it can only ever remove the
+	// lock this holder wrote, making a best-effort close safe.
+	await handle.close().catch(() => undefined);
+}
+
 async function syncParentDirectory(
 	fs: ConversationStoreFs,
 	directory: string,
@@ -544,7 +433,6 @@ function isConversationStoreLock(value: unknown): value is ConversationStoreLock
 		Number.isSafeInteger(value.pid) &&
 		value.pid > 0 &&
 		typeof value.incarnation === "string" &&
-		(value.isolateId === undefined || typeof value.isolateId === "string") &&
 		typeof value.timestamp === "number"
 	);
 }

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

@@ -1,3 +1,4 @@
+import * as crypto from "node:crypto";
 import * as path from "node:path";
 
 /**
@@ -19,8 +20,25 @@ export interface DaemonPaths {
 	diagnostic: string;
 	aliases: string;
 	seenUpdates: string;
+	ownerRegistry: string;
+	recoveryReceipt: string;
 }
 
+export function agentDirDigest(agentDir: string): string {
+	return crypto.createHash("sha256").update(path.resolve(agentDir)).digest("hex");
+}
+
+export function telegramDaemonOwnerMarkerPath(agentDir: string, acquisitionId: string): string {
+	const safe =
+		/^[A-Za-z0-9_.-]+$/.test(acquisitionId) && acquisitionId.length > 0 && acquisitionId.length <= 128
+			? acquisitionId
+			: crypto.createHash("sha256").update(acquisitionId).digest("hex");
+	return path.join(daemonPaths(agentDir).ownerRegistry, `${safe}.json`);
+}
+
+export const daemonOwnerMarkerPath = telegramDaemonOwnerMarkerPath;
+export const telegramDaemonProcessMarkerPath = telegramDaemonOwnerMarkerPath;
+
 export function daemonPaths(agentDir: string): DaemonPaths {
 	const dir = path.join(agentDir, "notifications");
 	return {
@@ -34,5 +52,7 @@ export function daemonPaths(agentDir: string): DaemonPaths {
 		aliases: path.join(dir, "telegram-callback-aliases.json"),
 		diagnostic: path.join(dir, "telegram-daemon.diagnostics.json"),
 		seenUpdates: path.join(dir, "telegram-seen-updates.json"),
+		ownerRegistry: path.join(dir, "telegram-daemon-owners"),
+		recoveryReceipt: path.join(dir, "telegram-daemon.recovery.json"),
 	};
 }

package/src/sdk/bus/discord-conversation.ts

@@ -9,6 +9,7 @@ export interface DiscordInboundDispatchReceipt {
 	actionId?: string;
 	actionNonce?: string;
 	endpointGeneration: number;
+	attachmentAuthorityId?: string;
 	effectId: string;
 	idempotencyKey: string;
 }
@@ -28,6 +29,7 @@ export interface DiscordConversation extends ConversationRecord {
 	createOwner?: string;
 	createLeaseExpiresAt?: number;
 	endpointGeneration?: number;
+	attachmentAuthorityId?: string;
 	/** Immutable lineage for archive and resume provider effects. */
 	effectIncarnationId?: string;
 	/** Current archive operation authority. */