clawmini 0.0.8 → 0.0.9

package/dist/adapter-google-chat/index.mjs

@@ -1,76 +1,19 @@
 #!/usr/bin/env node
-import { c as getClawminiDir, d as getSocketPath, f as getWorkspaceRoot } from "../workspace-BJmJBfKi.mjs";
+import { g as getWorkspaceRoot, h as getSocketPath, u as getClawminiDir } from "../workspace-oWmVh5mi.mjs";
 import { t as createUnixSocketFetch } from "../fetch-Cn1XNyiO.mjs";
-import { a as createUnixSocketEventSource, i as shouldDisplayMessage, n as handleAdapterCommand, r as formatMessage, t as handleRoutingCommand } from "../routing-D8rTxtaV.mjs";
+import { a as updateGoogleChatConfig, i as readGoogleChatConfig, n as initGoogleChatConfig, r as isAuthorized } from "../config-Dvl-Pov4.mjs";
+import { a as handleAdapterCommand, c as routeMessage, i as handleRoutingCommand, n as createUnixSocketEventSource, o as createInboundCache, r as prependBlockquote, s as formatMessage, t as createTurnLogBuffer } from "../turn-log-buffer-DRgW53gl.mjs";
 import fs from "node:fs";
 import path from "node:path";
-import fs$1 from "node:fs/promises";
+import crypto from "node:crypto";
+import fsPromises from "node:fs/promises";
 import { z } from "zod";
 import { createTRPCClient, httpLink, httpSubscriptionLink, splitLink } from "@trpc/client";
 import http from "node:http";
-import crypto from "node:crypto";
 import { PubSub } from "@google-cloud/pubsub";
 import { google } from "googleapis";
 import mime from "mime-types";
 
-//#region src/adapter-google-chat/config.ts
-const GoogleChatConfigSchema = z.looseObject({
-	projectId: z.string().min(1, "GCP Project ID is required."),
-	subscriptionName: z.string().min(1, "Pub/Sub Subscription Name is required."),
-	topicName: z.string().min(1, "Pub/Sub Topic Name is required."),
-	authorizedUsers: z.array(z.string()).min(1, "At least one Authorized User is required."),
-	maxAttachmentSizeMB: z.number().default(25).optional(),
-	chatId: z.string().default("default").optional(),
-	directMessageName: z.string().optional(),
-	driveUploadEnabled: z.boolean().default(true).optional(),
-	requireMention: z.boolean().default(false),
-	oauthClientId: z.string().optional(),
-	oauthClientSecret: z.string().optional()
-});
-function getGoogleChatConfigPath(startDir = process.cwd()) {
-	return path.join(getClawminiDir(startDir), "adapters", "google-chat", "config.json");
-}
-async function readGoogleChatConfig(startDir = process.cwd()) {
-	const configPath = getGoogleChatConfigPath(startDir);
-	try {
-		const data = await fs$1.readFile(configPath, "utf-8");
-		const parsed = JSON.parse(data);
-		return GoogleChatConfigSchema.parse(parsed);
-	} catch (err) {
-		if (err.code === "ENOENT") return null;
-		throw err;
-	}
-}
-async function updateGoogleChatConfig(config, startDir = process.cwd()) {
-	const configPath = getGoogleChatConfigPath(startDir);
-	await fs$1.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
-}
-async function initGoogleChatConfig(startDir = process.cwd()) {
-	const configPath = getGoogleChatConfigPath(startDir);
-	const configDir = path.dirname(configPath);
-	await fs$1.mkdir(configDir, { recursive: true });
-	if (fs.existsSync(configPath)) {
-		console.log(`Config file already exists at ${configPath}`);
-		return;
-	}
-	await fs$1.writeFile(configPath, JSON.stringify({
-		projectId: "YOUR_PROJECT_ID",
-		topicName: "YOUR_TOPIC_NAME",
-		subscriptionName: "YOUR_SUBSCRIPTION_NAME",
-		authorizedUsers: ["user@example.com"],
-		chatId: "default",
-		requireMention: false,
-		oauthClientId: "YOUR_OAUTH_CLIENT_ID",
-		oauthClientSecret: "YOUR_OAUTH_CLIENT_SECRET"
-	}, null, 2), "utf-8");
-	console.log(`Created template configuration file at ${configPath}`);
-	console.log("Please update it with your actual GCP Project ID, Pub/Sub Topic Name, Pub/Sub Subscription Name, and Authorized Users.");
-}
-function isAuthorized(userIdOrEmail, authorizedUsers) {
-	return authorizedUsers.some((u) => u.toLowerCase() === userIdOrEmail.toLowerCase());
-}
-
-//#endregion
 //#region src/adapter-google-chat/state.ts
 const GoogleChatStateSchema = z.object({
 	lastSyncedMessageIds: z.record(z.string(), z.string()).optional(),
@@ -78,7 +21,8 @@ const GoogleChatStateSchema = z.object({
 		chatId: z.string().nullable().optional(),
 		subscriptionId: z.string().optional(),
 		expirationDate: z.string().optional(),
-		requireMention: z.boolean().optional()
+		requireMention: z.boolean().optional(),
+		threadsDisabled: z.boolean().optional()
 	})).optional(),
 	oauthTokens: z.any().optional(),
 	filters: z.record(z.string(), z.boolean()).optional()
@@ -89,7 +33,7 @@ function getGoogleChatStatePath(startDir = process.cwd()) {
 async function readGoogleChatState(startDir = process.cwd()) {
 	const statePath = getGoogleChatStatePath(startDir);
 	try {
-		const data = await fs$1.readFile(statePath, "utf-8");
+		const data = await fsPromises.readFile(statePath, "utf-8");
 		const parsed = JSON.parse(data);
 		if (parsed.lastSyncedMessageId && !parsed.lastSyncedMessageIds) parsed.lastSyncedMessageIds = { default: parsed.lastSyncedMessageId };
 		if (parsed.driveOauthTokens && !parsed.oauthTokens) {
@@ -118,8 +62,10 @@ function updateGoogleChatState(updates, startDir = process.cwd()) {
 				};
 				const statePath = getGoogleChatStatePath(startDir);
 				const dir = path.dirname(statePath);
-				await fs$1.mkdir(dir, { recursive: true });
-				await fs$1.writeFile(statePath, JSON.stringify(newState, null, 2), "utf-8");
+				await fsPromises.mkdir(dir, { recursive: true });
+				const tmpPath = `${statePath}.${process.pid}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+				await fsPromises.writeFile(tmpPath, JSON.stringify(newState, null, 2), "utf-8");
+				await fsPromises.rename(tmpPath, statePath);
 				resolve(newState);
 			} catch (err) {
 				console.error(`Failed to write Google Chat state:`, err);
@@ -129,6 +75,29 @@ function updateGoogleChatState(updates, startDir = process.cwd()) {
 	});
 }
 
+//#endregion
+//#region src/adapter-google-chat/inbound-cache.ts
+/**
+* Google Chat-side wrapper around the shared inbound-message TTL cache.
+*
+* Ingestion records each inbound by its `gchatMessageName` (also sent to the
+* daemon as `externalRef`). When the forwarder later sees `turnStarted` with
+* that `externalRef`, it resolves the thread anchor by looking up the same
+* key here.
+*/
+const INBOUND_TTL_MS = 600 * 1e3;
+const cache = createInboundCache(INBOUND_TTL_MS);
+function recordInbound(entry) {
+	cache.record(entry.gchatMessageName, { gchatThreadName: entry.gchatThreadName });
+}
+function resolveInbound(gchatMessageName) {
+	const value = cache.resolve(gchatMessageName);
+	return value ? {
+		gchatMessageName,
+		gchatThreadName: value.gchatThreadName
+	} : null;
+}
+
 //#endregion
 //#region src/adapter-google-chat/utils.ts
 let authClient$1 = null;
@@ -223,32 +192,34 @@ async function getAuthClient() {
 	if (!authClient) authClient = await google.auth.getClient({ scopes: ["https://www.googleapis.com/auth/chat.bot"] });
 	return authClient;
 }
-let userAuthClient = null;
-let userAuthPromise = null;
-async function getUserAuthClient(config) {
-	if (userAuthClient) return userAuthClient;
-	if (userAuthPromise) return userAuthPromise;
+const userAuthClients = /* @__PURE__ */ new Map();
+const userAuthPromises = /* @__PURE__ */ new Map();
+async function getUserAuthClient(config, startDir = process.cwd()) {
+	const cached = userAuthClients.get(startDir);
+	if (cached) return cached;
+	const pending = userAuthPromises.get(startDir);
+	if (pending) return pending;
 	if (!config.oauthClientId || !config.oauthClientSecret) {
 		console.error("DEBUG config:", config);
 		throw new Error("oauthClientId and oauthClientSecret are required in config.json for user authentication.");
 	}
-	userAuthPromise = (async () => {
+	const promise = (async () => {
 		const oauth2Client = new google.auth.OAuth2(config.oauthClientId, config.oauthClientSecret, "http://localhost:31338/oauth2callback");
 		oauth2Client.on("tokens", async (tokens) => {
 			try {
 				await updateGoogleChatState({ oauthTokens: {
-					...(await readGoogleChatState()).oauthTokens,
+					...(await readGoogleChatState(startDir)).oauthTokens,
 					...tokens
-				} });
+				} }, startDir);
 			} catch (err) {
 				console.error("Failed to save refreshed Google User tokens", err);
 			}
 		});
-		const state = await readGoogleChatState();
+		const state = await readGoogleChatState(startDir);
 		if (state.oauthTokens) {
 			oauth2Client.setCredentials(state.oauthTokens);
-			userAuthClient = oauth2Client;
-			userAuthPromise = null;
+			userAuthClients.set(startDir, oauth2Client);
+			userAuthPromises.delete(startDir);
 			return oauth2Client;
 		}
 		const authUrl = oauth2Client.generateAuthUrl({
@@ -273,21 +244,21 @@ async function getUserAuthClient(config) {
 						try {
 							const { tokens } = await oauth2Client.getToken(code);
 							oauth2Client.setCredentials(tokens);
-							await updateGoogleChatState({ oauthTokens: tokens });
+							await updateGoogleChatState({ oauthTokens: tokens }, startDir);
 							console.log("Google User authorization successful!");
-							userAuthClient = oauth2Client;
-							userAuthPromise = null;
+							userAuthClients.set(startDir, oauth2Client);
+							userAuthPromises.delete(startDir);
 							resolve(oauth2Client);
 						} catch (err) {
 							console.error("Failed to get token", err);
-							userAuthPromise = null;
+							userAuthPromises.delete(startDir);
 							reject(err);
 						}
 					} else {
 						res.end("Authentication failed!");
 						clearTimeout(timeoutId);
 						server.close();
-						userAuthPromise = null;
+						userAuthPromises.delete(startDir);
 						reject(/* @__PURE__ */ new Error("No code provided in OAuth callback"));
 					}
 				}
@@ -295,27 +266,28 @@ async function getUserAuthClient(config) {
 			server.on("error", (err) => {
 				console.error("Failed to start local OAuth server on port 31338", err);
 				clearTimeout(timeoutId);
-				userAuthPromise = null;
+				userAuthPromises.delete(startDir);
 				reject(err);
 			});
 			server.listen(31338, "127.0.0.1", () => {
 				timeoutId = setTimeout(() => {
 					server.close();
-					userAuthPromise = null;
+					userAuthPromises.delete(startDir);
 					console.error("Google User authorization timed out after 5 minutes.");
 					reject(/* @__PURE__ */ new Error("Google User authorization timed out."));
 				}, 300 * 1e3);
 			});
 		});
 	})();
-	return userAuthPromise;
+	userAuthPromises.set(startDir, promise);
+	return promise;
 }
 
 //#endregion
 //#region src/adapter-google-chat/subscriptions.ts
-async function handleAddedToSpace(spaceName, externalContextId, spaceType, targetChatId, mappedChatId, config) {
+async function handleAddedToSpace(spaceName, externalContextId, spaceType, targetChatId, mappedChatId, config, startDir = process.cwd()) {
 	if (spaceType !== "DIRECT_MESSAGE") try {
-		const token = (await (await getUserAuthClient(config)).getAccessToken()).token;
+		const token = (await (await getUserAuthClient(config, startDir)).getAccessToken()).token;
 		if (token) {
 			const res = await fetch("https://workspaceevents.googleapis.com/v1/subscriptions", {
 				method: "POST",
@@ -342,7 +314,7 @@ async function handleAddedToSpace(spaceName, externalContextId, spaceType, targe
 							expirationDate: subData.expireTime
 						}
 					} };
-				});
+				}, startDir);
 				console.log(`Created subscription ${subData.name} for space ${externalContextId}`);
 			} else {
 				const errText = await res.text();
@@ -365,10 +337,10 @@ async function handleAddedToSpace(spaceName, externalContextId, spaceType, targe
 		console.error("Failed to send greeting on ADDED_TO_SPACE:", err);
 	}
 }
-async function handleRemovedFromSpace(externalContextId, currentState, config) {
+async function handleRemovedFromSpace(externalContextId, currentState, config, startDir = process.cwd()) {
 	const subId = currentState.channelChatMap?.[externalContextId]?.subscriptionId;
 	if (subId) try {
-		const token = (await (await getUserAuthClient(config)).getAccessToken()).token;
+		const token = (await (await getUserAuthClient(config, startDir)).getAccessToken()).token;
 		if (token) {
 			const res = await fetch(`https://workspaceevents.googleapis.com/v1/${subId}`, {
 				method: "DELETE",
@@ -392,12 +364,12 @@ async function handleRemovedFromSpace(externalContextId, currentState, config) {
 			delete entry.expirationDate;
 		}
 		return { channelChatMap: map };
-	});
+	}, startDir);
 }
 
 //#endregion
 //#region src/adapter-google-chat/cards.ts
-async function handleCardClicked(event, targetChatId, trpc) {
+async function handleCardClicked(event, targetChatId, trpc, getChatApi) {
 	const action = event.action;
 	if (!action) return;
 	const methodName = action.actionMethodName;
@@ -405,7 +377,7 @@ async function handleCardClicked(event, targetChatId, trpc) {
 	if (policyId && (methodName === "approve" || methodName === "reject")) {
 		const cmd = methodName === "approve" ? `/approve ${policyId}` : `/reject ${policyId}`;
 		if (event.message?.name) try {
-			const chatApi = google.chat({
+			const chatApi = getChatApi ? await getChatApi() : google.chat({
 				version: "v1",
 				auth: await getAuthClient()
 			});
@@ -462,8 +434,31 @@ function getTRPCClient(options = {}) {
 		})
 	})] });
 }
-function startGoogleChatIngestion(config, trpc, filteringConfig) {
-	const subscription = new PubSub({ projectId: config.projectId }).subscription(config.subscriptionName);
+/**
+* Map a quoted message's sender to a short attribution label. Returns "Bot"
+* for the assistant, "You" if it's one of the configured authorized users,
+* and otherwise the sender's email (preferred) or `users/{id}` resource name.
+*/
+function formatQuotedSender(sender, authorizedUsers) {
+	if (!sender) return void 0;
+	if (sender.type === "BOT") return "Assistant";
+	const email = sender.email ?? void 0;
+	const name = sender.name ?? void 0;
+	if (email && isAuthorized(email, authorizedUsers) || name && isAuthorized(name, authorizedUsers)) return;
+	return email || sender.displayName || name || void 0;
+}
+function startGoogleChatIngestion(config, trpc, filteringConfig, deps = {}) {
+	const startDir = deps.startDir ?? process.cwd();
+	const subscription = deps.subscription ?? new PubSub({ projectId: config.projectId }).subscription(config.subscriptionName);
+	const getChatApi = async () => {
+		if (deps.chatApi) return deps.chatApi;
+		const authClient = await getAuthClient();
+		return google.chat({
+			version: "v1",
+			auth: authClient
+		});
+	};
+	const downloadAttachment$1 = deps.downloadAttachment ?? downloadAttachment;
 	const seenMessageIds = /* @__PURE__ */ new Map();
 	setInterval(() => {
 		const now = Date.now();
@@ -482,8 +477,8 @@ function startGoogleChatIngestion(config, trpc, filteringConfig) {
 			const space = isWorkspaceEvent ? eventMessage?.space : parsedData.space || eventMessage?.space;
 			const senderType = eventMessage?.sender?.type || "";
 			const messageId = eventMessage?.name || "";
-			const text = (eventMessage?.argumentText || eventMessage?.text || "").trim();
-			if (senderType === "BOT") return void message.ack();
+			const text = (eventMessage?.text || "").trim();
+			if (senderType === "BOT" && eventType !== "CARD_CLICKED") return void message.ack();
 			if (messageId) {
 				if (seenMessageIds.has(messageId)) return void message.ack();
 				seenMessageIds.set(messageId, Date.now());
@@ -507,7 +502,7 @@ function startGoogleChatIngestion(config, trpc, filteringConfig) {
 			if (authorizedByEmail && senderName && !isAuthorized(senderName, config.authorizedUsers)) {
 				console.log(`Automatically authorizing user ID ${senderName} based on authorized email ${email}`);
 				config.authorizedUsers.push(senderName);
-				updateGoogleChatConfig(config).catch((err) => console.error("Failed to update config with new user ID:", err));
+				updateGoogleChatConfig(config, startDir).catch((err) => console.error("Failed to update config with new user ID:", err));
 			}
 			const identifier = email || senderName;
 			const spaceName = space?.name;
@@ -516,19 +511,19 @@ function startGoogleChatIngestion(config, trpc, filteringConfig) {
 				message.ack();
 				return;
 			}
-			const currentState = await readGoogleChatState();
+			const currentState = await readGoogleChatState(startDir);
 			const externalContextId = spaceName;
 			const mappedChatId = currentState.channelChatMap?.[externalContextId]?.chatId;
 			const isRoutingCommand = text.startsWith("/chat") || text.startsWith("/agent");
 			if (eventType === "ADDED_TO_SPACE") {
-				await handleAddedToSpace(spaceName, externalContextId, space?.type, mappedChatId, mappedChatId, config);
+				await handleAddedToSpace(spaceName, externalContextId, space?.type, mappedChatId, mappedChatId, config, startDir);
 				if (!text) {
 					message.ack();
 					return;
 				}
 			}
 			if (eventType === "REMOVED_FROM_SPACE") {
-				await handleRemovedFromSpace(externalContextId, currentState, config);
+				await handleRemovedFromSpace(externalContextId, currentState, config, startDir);
 				message.ack();
 				return;
 			}
@@ -541,13 +536,9 @@ function startGoogleChatIngestion(config, trpc, filteringConfig) {
 							...latestState.channelChatMap?.[externalContextId] || {},
 							chatId: routingResult.newChatId
 						}
-					} }));
+					} }), startDir);
 					try {
-						const authClient = await getAuthClient();
-						await google.chat({
-							version: "v1",
-							auth: authClient
-						}).spaces.messages.create({
+						await (await getChatApi()).spaces.messages.create({
 							parent: externalContextId,
 							requestBody: { text: routingResult.text }
 						});
@@ -568,7 +559,7 @@ function startGoogleChatIngestion(config, trpc, filteringConfig) {
 						...latestState.channelChatMap?.[externalContextId] || {},
 						chatId: targetChatId
 					}
-				} }));
+				} }), startDir);
 			} else {
 				const isDirectMessage = space?.type === "DIRECT_MESSAGE" || space?.singleUserBotDm === true;
 				const isMentioned = Array.isArray(eventMessage?.annotations) && eventMessage.annotations.some((a) => a.type === "USER_MENTION");
@@ -576,11 +567,7 @@ function startGoogleChatIngestion(config, trpc, filteringConfig) {
 				if (isDirectMessage || isMentioned || isSlashCommand) {
 					console.log(`Unmapped space ${externalContextId}, sending first contact warning.`);
 					try {
-						const authClient = await getAuthClient();
-						await google.chat({
-							version: "v1",
-							auth: authClient
-						}).spaces.messages.create({
+						await (await getChatApi()).spaces.messages.create({
 							parent: externalContextId,
 							requestBody: { text: "This channel/space is not currently mapped to a daemon chat. Please use `/chat [chat-id]` or `/agent [agent-id]` to map it." }
 						});
@@ -598,11 +585,7 @@ function startGoogleChatIngestion(config, trpc, filteringConfig) {
 					const isMentioned = Array.isArray(eventMessage?.annotations) && eventMessage.annotations.some((a) => a.type === "USER_MENTION" && a.userMention?.user?.type === "BOT");
 					let isReplyToBot = false;
 					if (eventMessage?.threadReply && eventMessage.thread?.name) try {
-						const authClient = await getAuthClient();
-						isReplyToBot = (await google.chat({
-							version: "v1",
-							auth: authClient
-						}).spaces.messages.list({
+						isReplyToBot = (await (await getChatApi()).spaces.messages.list({
 							parent: externalContextId,
 							filter: `thread.name="${eventMessage.thread.name}"`
 						})).data.messages?.some((m) => m.sender?.type === "BOT" || m.annotations?.some((a) => a.type === "USER_MENTION" && a.userMention?.user?.type === "BOT")) ?? false;
@@ -616,7 +599,7 @@ function startGoogleChatIngestion(config, trpc, filteringConfig) {
 				}
 			}
 			if (eventType === "CARD_CLICKED") {
-				await handleCardClicked(parsedData, targetChatId, trpc);
+				await handleCardClicked(parsedData, targetChatId, trpc, getChatApi);
 				message.ack();
 				return;
 			}
@@ -626,15 +609,11 @@ function startGoogleChatIngestion(config, trpc, filteringConfig) {
 				if (commandResult.type === "text") {
 					if (commandResult.newConfig) {
 						filteringConfig.filters = commandResult.newConfig.filters;
-						await updateGoogleChatState({ filters: filteringConfig.filters });
+						await updateGoogleChatState({ filters: filteringConfig.filters }, startDir);
 					}
 					resultText = commandResult.text;
 				} else if (commandResult.type === "debug") resultText = commandResult.messages.length === 0 ? "No ignored background messages found." : `**Debug Output (${commandResult.messages.length} ignored messages):**\n\n` + commandResult.messages.map((msg) => formatMessage(msg)).join("\n\n---\n\n");
-				const authClient = await getAuthClient();
-				await google.chat({
-					version: "v1",
-					auth: authClient
-				}).spaces.messages.create({
+				await (await getChatApi()).spaces.messages.create({
 					parent: spaceName,
 					requestBody: { text: resultText }
 				});
@@ -643,30 +622,53 @@ function startGoogleChatIngestion(config, trpc, filteringConfig) {
 			}
 			const attachments = eventMessage?.attachment || [];
 			if (attachments.length > 0) {
-				const tmpDir = path.join(getClawminiDir(process.cwd()), "tmp", "google-chat");
-				await fs$1.mkdir(tmpDir, { recursive: true });
+				const tmpDir = path.join(getClawminiDir(startDir), "tmp", "google-chat");
+				await fsPromises.mkdir(tmpDir, { recursive: true });
 				for (const att of attachments) {
 					const resourceName = att.attachmentDataRef?.resourceName;
 					if (resourceName) try {
-						const buffer = await downloadAttachment(resourceName, config.maxAttachmentSizeMB);
+						const buffer = await downloadAttachment$1(resourceName, config.maxAttachmentSizeMB);
 						const uniqueName = `${crypto.randomUUID()}-${att.contentName || "attachment"}`;
 						const filePath = path.join(tmpDir, uniqueName);
-						await fs$1.writeFile(filePath, buffer);
+						await fsPromises.writeFile(filePath, buffer);
 						downloadedFiles.push(filePath);
 					} catch (err) {
 						console.error(`Error downloading attachment:`, err);
 					}
 				}
 			}
+			let forwardedText = text;
+			const quotedMetadata = eventMessage?.quotedMessageMetadata;
+			if (quotedMetadata) {
+				let quotedText = quotedMetadata.quotedMessageSnapshot?.text;
+				let quotedSender = quotedMetadata.quotedMessageSnapshot?.sender;
+				if ((!quotedText || !quotedSender) && quotedMetadata.name) try {
+					const quotedRes = await (await getChatApi()).spaces.messages.get({ name: quotedMetadata.name });
+					quotedText = quotedText || quotedRes.data?.text || void 0;
+					quotedSender = quotedSender || quotedRes.data?.sender || void 0;
+				} catch (err) {
+					console.error("Failed to fetch quoted message:", err);
+				}
+				if (quotedText) {
+					const senderLabel = formatQuotedSender(quotedSender, config.authorizedUsers);
+					forwardedText = prependBlockquote(quotedText, text, senderLabel);
+				}
+			}
+			const gchatThreadName = eventMessage?.thread?.name ?? eventMessage?.threadName ?? void 0;
+			if (messageId && gchatThreadName) recordInbound({
+				gchatMessageName: messageId,
+				gchatThreadName
+			});
 			await trpc.sendMessage.mutate({
 				type: "send-message",
 				client: "cli",
 				data: {
-					message: text,
+					message: forwardedText,
 					chatId: targetChatId,
 					files: downloadedFiles.length > 0 ? downloadedFiles : void 0,
 					adapter: "google-chat",
-					noWait: true
+					noWait: true,
+					...messageId ? { externalRef: messageId } : {}
 				}
 			});
 			console.log(`Forwarded message from ${identifier} to daemon.`);
@@ -674,7 +676,7 @@ function startGoogleChatIngestion(config, trpc, filteringConfig) {
 		} catch (error) {
 			console.error("Error processing Pub/Sub message:", error);
 			for (const file of downloadedFiles) try {
-				await fs$1.unlink(file);
+				await fsPromises.unlink(file);
 			} catch (unlinkErr) {
 				console.error(`Failed to delete downloaded file ${file} after error:`, unlinkErr);
 			}
@@ -762,10 +764,62 @@ async function uploadFilesToDrive(files, config) {
 
 //#endregion
 //#region src/adapter-google-chat/forwarder.ts
-async function startDaemonToGoogleChatForwarder(trpc, config, filteringConfig, signal) {
+const DEFAULT_THREAD_LOG_OPTS = {
+	maxToolPreview: 400,
+	maxLogMessageChars: 3500,
+	editDebounceMs: 1e3
+};
+function resolveThreadLogOpts(config) {
+	const v = config.visibility?.threadLog;
+	return {
+		maxToolPreview: v?.maxToolPreview ?? DEFAULT_THREAD_LOG_OPTS.maxToolPreview,
+		maxLogMessageChars: v?.maxLogMessageChars ?? DEFAULT_THREAD_LOG_OPTS.maxLogMessageChars,
+		editDebounceMs: v?.editDebounceMs ?? DEFAULT_THREAD_LOG_OPTS.editDebounceMs
+	};
+}
+async function resolveSpaceForChat(chatId, startDir) {
+	const state = await readGoogleChatState(startDir);
+	const entry = Object.entries(state.channelChatMap || {}).find(([, v]) => v?.chatId === chatId);
+	if (!entry) return null;
+	const [spaceName, mapping] = entry;
+	return {
+		spaceName,
+		threadsDisabled: mapping.threadsDisabled === true
+	};
+}
+async function startDaemonToGoogleChatForwarder(trpc, config, filteringConfig, signal, deps = {}) {
 	const defaultChatId = config.chatId || "default";
+	const startDir = deps.startDir ?? process.cwd();
+	const threadLogOpts = resolveThreadLogOpts(config);
+	const threadsGloballyEnabled = config.visibility?.threads !== false;
+	const jobsMode = config.visibility?.jobs ?? "silent";
+	const getChatApi = async () => {
+		if (deps.chatApi) return deps.chatApi;
+		const authClient = await getAuthClient();
+		return google.chat({
+			version: "v1",
+			auth: authClient
+		});
+	};
 	const activeSubscriptions = /* @__PURE__ */ new Map();
-	let currentLastSyncedMessageIds = (await readGoogleChatState()).lastSyncedMessageIds || {};
+	/**
+	* When a turn has no inbound-user anchor (cron, subagent completion, any
+	* proactive turn), its first top-level post implicitly creates a GChat
+	* thread. Record `daemonMessageId -> gchatThreadName` here so a late
+	* `turnStarted` event can still resolve the anchor. LRU-bounded to keep
+	* memory predictable on long-running daemons.
+	*/
+	const proactiveAnchors = /* @__PURE__ */ new Map();
+	const MAX_PROACTIVE_ANCHORS = 64;
+	const recordProactiveAnchor = (daemonMessageId, threadName) => {
+		while (proactiveAnchors.size >= MAX_PROACTIVE_ANCHORS) {
+			const oldest = proactiveAnchors.keys().next().value;
+			if (!oldest) break;
+			proactiveAnchors.delete(oldest);
+		}
+		proactiveAnchors.set(daemonMessageId, threadName);
+	};
+	let currentLastSyncedMessageIds = (await readGoogleChatState(startDir)).lastSyncedMessageIds || {};
 	const saveLastMessageId = async (chatId, id) => {
 		currentLastSyncedMessageIds = {
 			...currentLastSyncedMessageIds,
@@ -774,7 +828,165 @@ async function startDaemonToGoogleChatForwarder(trpc, config, filteringConfig, s
 		return updateGoogleChatState((state) => ({ lastSyncedMessageIds: {
 			...state.lastSyncedMessageIds,
 			...currentLastSyncedMessageIds
-		} }));
+		} }), startDir);
+	};
+	/**
+	* Post a top-level message (no `thread` field; GChat auto-creates a fresh
+	* thread). Returns the newly-created thread's `name` so callers can anchor
+	* subsequent threaded replies on it — used to thread activity under
+	* proactive turns (cron, subagent_update) that have no inbound user
+	* message to anchor on.
+	*/
+	const postTopLevel = async (spaceName, text, cardsV2) => {
+		const chatApi = await getChatApi();
+		const extractThread = (res) => {
+			return (res.data ?? res)?.thread?.name ?? void 0;
+		};
+		if (cardsV2 && cardsV2.length > 0) return { threadName: extractThread(await chatApi.spaces.messages.create({
+			parent: spaceName,
+			requestBody: {
+				text: text || "",
+				cardsV2
+			}
+		})) };
+		if (text.length > 4e3) {
+			const chunks = chunkString(text, 4e3);
+			let firstThread;
+			for (const chunk of chunks) {
+				const res = await chatApi.spaces.messages.create({
+					parent: spaceName,
+					requestBody: { text: chunk }
+				});
+				firstThread ??= extractThread(res);
+			}
+			return { threadName: firstThread };
+		}
+		return { threadName: extractThread(await chatApi.spaces.messages.create({
+			parent: spaceName,
+			requestBody: { text }
+		})) };
+	};
+	const postThreaded = async (anchor, text) => {
+		const res = await (await getChatApi()).spaces.messages.create({
+			parent: anchor.spaceName,
+			requestBody: {
+				text: text || "",
+				thread: { name: anchor.threadName }
+			},
+			messageReplyOption: "REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD"
+		});
+		return (res.data ?? res)?.name ?? void 0;
+	};
+	const editThreaded = async (_anchor, messageName, text) => {
+		await (await getChatApi()).spaces.messages.update({
+			name: messageName,
+			updateMask: "text",
+			requestBody: { text }
+		});
+	};
+	const isMissingMessageError = (err) => {
+		return (err?.code ?? 0) === 404;
+	};
+	const turnLog = createTurnLogBuffer({
+		postThreaded,
+		editThreaded,
+		isMissingMessageError,
+		options: threadLogOpts,
+		threadsEnabled: threadsGloballyEnabled
+	});
+	const handlePolicyCard = async (message, spaceName) => {
+		const cards = buildPolicyCard(message);
+		try {
+			await postTopLevel(spaceName, "", cards);
+		} catch (richError) {
+			console.warn("Failed to send rich policy request to Google Chat, falling back to plain text:", richError);
+			const policyId = "requestId" in message && message.requestId || message.id;
+			await postTopLevel(spaceName, `Action Required: Policy Request\n\n${message.content || "A pending policy request requires your attention."}\n\nApprove: \`/approve ${policyId}\`\nReject: \`/reject ${policyId} <optional_rationale>\``);
+		}
+	};
+	const collapseDestination = (dest, turnId) => {
+		if (dest.kind !== "thread-log") return dest;
+		if (!threadsGloballyEnabled) return { kind: "drop" };
+		if (turnId && turnLog.threadsDisabledFor(turnId)) return { kind: "drop" };
+		return dest;
+	};
+	const handleMessageForChat = async (chatId, message) => {
+		const routed = routeMessage(message, filteringConfig);
+		const isCronHeader = jobsMode === "header" && message.role === "system" && message.event === "cron";
+		const effective = collapseDestination(routed, message.turnId);
+		if (!isCronHeader && effective.kind === "drop") return;
+		const space = await resolveSpaceForChat(chatId, startDir);
+		if (!space) {
+			console.warn("No active Google Chat space to reply to. Ignoring message:", message.content);
+			return;
+		}
+		if ("level" in message && message.level === "verbose") return;
+		const hasContent = !!message.content?.trim();
+		const files = "files" in message ? message.files ?? [] : [];
+		const hasFiles = files.length > 0;
+		if (!isCronHeader && effective.kind === "thread-log") {
+			if (!message.turnId) {
+				console.warn(`thread-log event for ${message.role} has no turnId — dropping.`);
+				return;
+			}
+			if (!turnLog.has(message.turnId)) return;
+			turnLog.append(message.turnId, message);
+			return;
+		}
+		if (!isCronHeader && !hasContent && !hasFiles && message.role !== "policy") return;
+		try {
+			if (message.role === "policy" && message.status === "pending") {
+				await handlePolicyCard(message, space.spaceName);
+				return;
+			}
+			let text;
+			if (isCronHeader) text = `🕒 ${message.jobId ?? "scheduled"}`;
+			else text = formatMessage(message) || "";
+			if (hasFiles) {
+				const fileNames = files.map((f) => path.basename(f)).join(", ");
+				if (config.driveUploadEnabled !== false && config.oauthClientId && config.oauthClientSecret) {
+					text += `\n\n`;
+					try {
+						const uploadResults = await uploadFilesToDrive(files, config);
+						for (const result of uploadResults) text += `${result}\n`;
+					} catch (driveAuthErr) {
+						console.error("Drive API/Auth Failed, degrading to local files output:", driveAuthErr);
+						text += `*(Files generated: ${fileNames})*`;
+					}
+				} else text += `\n\n*(Files generated: ${fileNames})*`;
+			}
+			const { threadName: createdThread } = await postTopLevel(space.spaceName, text);
+			if (createdThread && message.turnId) if (turnLog.has(message.turnId)) {
+				if (!turnLog.isAnchored(message.turnId)) turnLog.assignAnchor(message.turnId, {
+					spaceName: space.spaceName,
+					threadName: createdThread
+				});
+			} else recordProactiveAnchor(message.id, createdThread);
+		} catch (err) {
+			console.error("Failed to send message to Google Chat:", err);
+		}
+	};
+	const handleTurnStarted = async (chatId, turnId, rootMessageId, externalRef) => {
+		const space = await resolveSpaceForChat(chatId, startDir);
+		if (!space) {
+			console.warn(`turnStarted for chat ${chatId} with no mapped space.`);
+			return;
+		}
+		const entry = externalRef ? resolveInbound(externalRef) : null;
+		const proactiveThread = entry ? void 0 : proactiveAnchors.get(rootMessageId);
+		if (proactiveThread) proactiveAnchors.delete(rootMessageId);
+		const threadName = entry?.gchatThreadName ?? proactiveThread;
+		turnLog.start({
+			turnId,
+			threadsDisabled: space.threadsDisabled,
+			anchorThread: threadName ? {
+				spaceName: space.spaceName,
+				threadName
+			} : void 0
+		});
+	};
+	const handleTurnEnded = async (turnId) => {
+		await turnLog.end(turnId);
 	};
 	const startSubscriptionForChat = async (chatId) => {
 		if (activeSubscriptions.has(chatId)) return;
@@ -800,120 +1012,29 @@ async function startDaemonToGoogleChatForwarder(trpc, config, filteringConfig, s
 		let retryDelay = 1e3;
 		const maxRetryDelay = 3e4;
 		let subscription = null;
-		let messageQueue = Promise.resolve();
+		let pending = Promise.resolve();
 		const connect = () => {
 			if (signal?.aborted || !activeSubscriptions.has(chatId)) return;
 			subscription = trpc.waitForMessages.subscribe({
 				chatId,
 				lastMessageId
 			}, {
-				onData: (messages) => {
+				onData: (items) => {
 					retryDelay = 1e3;
-					if (!Array.isArray(messages) || messages.length === 0) return;
-					messageQueue = messageQueue.then(async () => {
-						for (const rawMessage of messages) {
+					if (!Array.isArray(items) || items.length === 0) return;
+					pending = pending.then(async () => {
+						for (const raw of items) {
 							if (signal?.aborted || !activeSubscriptions.has(chatId)) break;
-							const message = rawMessage;
-							if (shouldDisplayMessage(message, filteringConfig)) {
-								const logMessage = message;
-								const currentState = await readGoogleChatState();
-								let activeSpaceName;
-								if (!activeSpaceName && currentState.channelChatMap) {
-									const entry = Object.entries(currentState.channelChatMap).find(([_, mapChatId]) => mapChatId?.chatId === chatId);
-									if (entry) activeSpaceName = entry[0];
-								}
-								if (logMessage.role === "policy" && logMessage.status === "pending") {
-									if (!activeSpaceName) {
-										console.warn("No active Google Chat space to reply to. Ignoring policy request:", logMessage.content);
-										await saveLastMessageId(chatId, logMessage.id).catch(console.error);
-										lastMessageId = logMessage.id;
-										continue;
-									}
-									try {
-										const client = await getAuthClient();
-										const chatApi = google.chat({
-											version: "v1",
-											auth: client
-										});
-										try {
-											await chatApi.spaces.messages.create({
-												parent: activeSpaceName,
-												requestBody: {
-													text: "",
-													cardsV2: buildPolicyCard(logMessage)
-												}
-											});
-										} catch (richError) {
-											console.warn("Failed to send rich policy request to Google Chat, falling back to plain text:", richError);
-											const policyId = "requestId" in logMessage && logMessage.requestId || logMessage.id;
-											await chatApi.spaces.messages.create({
-												parent: activeSpaceName,
-												requestBody: { text: `Action Required: Policy Request\n\n${logMessage.content || "A pending policy request requires your attention."}\n\nApprove: \`/approve ${policyId}\`\nReject: \`/reject ${policyId} <optional_rationale>\`` }
-											});
-										}
-									} catch (error) {
-										console.error("Failed to send policy request to Google Chat:", error);
-									}
-									await saveLastMessageId(chatId, logMessage.id).catch(console.error);
-									lastMessageId = logMessage.id;
-									continue;
-								}
-								const hasContent = !!logMessage.content?.trim();
-								const files = "files" in logMessage ? logMessage.files : void 0;
-								const hasFiles = Array.isArray(files) && files.length > 0;
-								if ("level" in logMessage && logMessage.level === "verbose" || !hasContent && !hasFiles) {
-									await saveLastMessageId(chatId, logMessage.id).catch(console.error);
-									lastMessageId = logMessage.id;
-									continue;
-								}
-								if (!activeSpaceName) {
-									console.warn("No active Google Chat space to reply to. Ignoring message:", logMessage.content);
-									await saveLastMessageId(chatId, logMessage.id).catch(console.error);
-									lastMessageId = logMessage.id;
-									continue;
-								}
-								try {
-									const client = await getAuthClient();
-									const chatApi = google.chat({
-										version: "v1",
-										auth: client
-									});
-									let text = formatMessage(logMessage) || "";
-									if (hasFiles && files) {
-										const fileNames = files.map((f) => path.basename(f)).join(", ");
-										if (config.driveUploadEnabled !== false && config.oauthClientId && config.oauthClientSecret) {
-											text += `\n\n`;
-											try {
-												const uploadResults = await uploadFilesToDrive(files, config);
-												for (const result of uploadResults) text += `${result}\n`;
-											} catch (driveAuthErr) {
-												console.error("Drive API/Auth Failed, degrading to local files output:", driveAuthErr);
-												text += `*(Files generated: ${fileNames})*`;
-											}
-										} else text += `\n\n*(Files generated: ${fileNames})*`;
-									}
-									if (text.length > 4e3) {
-										const chunks = chunkString(text, 4e3);
-										for (let i = 0; i < chunks.length; i++) {
-											if (signal?.aborted || !activeSubscriptions.has(chatId)) break;
-											await chatApi.spaces.messages.create({
-												parent: activeSpaceName,
-												requestBody: { text: chunks[i] }
-											});
-										}
-									} else await chatApi.spaces.messages.create({
-										parent: activeSpaceName,
-										requestBody: { text }
-									});
-								} catch (error) {
-									console.error("Failed to send message to Google Chat:", error);
-								}
-							}
-							await saveLastMessageId(chatId, message.id).catch(console.error);
-							lastMessageId = message.id;
+							const item = raw;
+							if (item.kind === "message") {
+								await handleMessageForChat(chatId, item.message);
+								await saveLastMessageId(chatId, item.message.id).catch(console.error);
+								lastMessageId = item.message.id;
+							} else if (item.event.type === "started") await handleTurnStarted(chatId, item.event.turnId, item.event.rootMessageId, item.event.externalRef);
+							else await handleTurnEnded(item.event.turnId);
 						}
 					}).catch((error) => {
-						console.error("Message queue failed, forcing reconnect...", error);
+						console.error("Stream queue failed, forcing reconnect...", error);
 						subscription?.unsubscribe();
 						subscription = null;
 						if (signal?.aborted || !activeSubscriptions.has(chatId)) return;
@@ -939,12 +1060,14 @@ async function startDaemonToGoogleChatForwarder(trpc, config, filteringConfig, s
 				}
 			});
 		};
-		activeSubscriptions.set(chatId, { unsubscribe: () => subscription?.unsubscribe() });
+		activeSubscriptions.set(chatId, { unsubscribe: () => {
+			subscription?.unsubscribe();
+		} });
 		connect();
 	};
 	const syncSubscriptions = async () => {
 		if (signal?.aborted) return;
-		const state = await readGoogleChatState();
+		const state = await readGoogleChatState(startDir);
 		if (state.lastSyncedMessageIds) currentLastSyncedMessageIds = {
 			...state.lastSyncedMessageIds,
 			...currentLastSyncedMessageIds
@@ -962,11 +1085,11 @@ async function startDaemonToGoogleChatForwarder(trpc, config, filteringConfig, s
 	};
 	return new Promise((resolve) => {
 		syncSubscriptions().catch(console.error);
-		const statePath = getGoogleChatStatePath();
+		const statePath = getGoogleChatStatePath(startDir);
 		const stateDir = path.dirname(statePath);
 		if (!fs.existsSync(stateDir)) fs.mkdirSync(stateDir, { recursive: true });
 		let debounceTimer = null;
-		const watcher = fs.watch(stateDir, (eventType, filename) => {
+		const watcher = fs.watch(stateDir, (_eventType, filename) => {
 			if (filename === path.basename(statePath)) {
 				if (debounceTimer) clearTimeout(debounceTimer);
 				debounceTimer = setTimeout(() => {
@@ -978,6 +1101,7 @@ async function startDaemonToGoogleChatForwarder(trpc, config, filteringConfig, s
 			if (debounceTimer) clearTimeout(debounceTimer);
 			watcher.close();
 			for (const sub of activeSubscriptions.values()) sub.unsubscribe();
+			turnLog.shutdown();
 			resolve();
 		});
 	});