clawmini 0.0.8 → 0.0.9

package/dist/turn-log-buffer-DRgW53gl.mjs

@@ -0,0 +1,767 @@
+import http from "node:http";
+
+//#region src/shared/adapters/filtering.ts
+/**
+* Legacy boolean. Returns true if the message role is permitted to be
+* displayed at all; adapters that haven't migrated to `routeMessage` keep
+* using this unchanged.
+*/
+function shouldDisplayMessage(message, config) {
+	const overrides = config.filters || {};
+	if (message.subagentId && overrides["subagent"] !== true) return false;
+	if (message.displayRole === "agent" || message.role === "agent" || message.role === "legacy_log" || message.role === "policy" && message.status === "pending") return true;
+	if (message.subagentId && overrides["subagent"] === true && (message.role === "user" || message.displayRole === "user")) return true;
+	if (overrides[message.role] === true || message.displayRole && overrides[message.displayRole] === true) return true;
+	return false;
+}
+function defaultDestinationForRole(message) {
+	if (message.role === "user") return { kind: "drop" };
+	if (message.role === "agent") return { kind: "top-level" };
+	if (message.role === "legacy_log") return { kind: "top-level" };
+	if (message.role === "tool") return { kind: "thread-log" };
+	if (message.role === "subagent_status") return { kind: "thread-log" };
+	if (message.role === "command") return { kind: "drop" };
+	if (message.role === "policy") return message.status === "pending" ? { kind: "top-level" } : { kind: "thread-log" };
+	if (message.role === "system") {
+		if (message.event === "cron") return { kind: "drop" };
+		if (message.event === "policy_approved" || message.event === "policy_rejected") return { kind: "thread-log" };
+		if (message.event === "subagent_update") return { kind: "thread-log" };
+		return { kind: "top-level" };
+	}
+	return { kind: "drop" };
+}
+/**
+* Return the destination for a chat message given the adapter's filtering
+* config. Adapters that support threaded activity logs (Google Chat) use this
+* to decide whether each message becomes a top-level post, a thread-log entry,
+* or is dropped entirely.
+*
+* A filter override of `true` on a role whose default destination is `drop`
+* promotes it to `top-level` (matching the legacy "opted in → show" behavior).
+* A filter override of `false` drops the role.
+*
+* Subagent messages route to their default destination when that default is a
+* thread one (tool calls, command logs, status updates all belong in the turn
+* log). They are dropped when the default is top-level — subagent prompts and
+* final replies are orchestration, not user-facing content — unless
+* `filters.subagent` is `true`, which surfaces them at top-level for debugging.
+*/
+function routeMessage(message, config) {
+	const overrides = config.filters || {};
+	const defaultDest = defaultDestinationForRole(message);
+	if (message.subagentId) {
+		if (overrides["subagent"] === true) return defaultDest.kind === "drop" ? { kind: "top-level" } : defaultDest;
+		return { kind: "thread-log" };
+	}
+	if (message.displayRole === "agent" || message.role === "agent" || message.role === "legacy_log" || message.role === "policy" && message.status === "pending") return defaultDest;
+	const roleFilter = overrides[message.role];
+	const displayRoleFilter = message.displayRole ? overrides[message.displayRole] : void 0;
+	if (roleFilter === false || displayRoleFilter === false) return { kind: "drop" };
+	if (roleFilter === true || displayRoleFilter === true) return defaultDest.kind === "drop" ? { kind: "top-level" } : defaultDest;
+	return defaultDest;
+}
+function formatMessage(message) {
+	if (message.role === "system" && !message.displayRole && !message.subagentId) return `[SYSTEM] ${message.content}`;
+	if (!message.subagentId) return message.content;
+	if (message.role === "user" || message.displayRole === "user") return `[To:${message.subagentId}]\n${message.content}`;
+	return `[From:${message.subagentId}]\n${message.content}`;
+}
+
+//#endregion
+//#region src/shared/adapters/inbound-cache.ts
+function createInboundCache(ttlMs) {
+	const cache = /* @__PURE__ */ new Map();
+	const sweep = (now) => {
+		for (const [key, entry] of cache) if (now - entry.receivedAt > ttlMs) cache.delete(key);
+	};
+	return {
+		record(key, value) {
+			const now = Date.now();
+			sweep(now);
+			cache.set(key, {
+				value,
+				receivedAt: now
+			});
+		},
+		resolve(key) {
+			const entry = cache.get(key);
+			if (!entry) return null;
+			if (Date.now() - entry.receivedAt > ttlMs) {
+				cache.delete(key);
+				return null;
+			}
+			return entry.value;
+		},
+		reset() {
+			cache.clear();
+		}
+	};
+}
+
+//#endregion
+//#region src/shared/adapters/commands.ts
+const VALID_ROLES = new Set([
+	"subagent",
+	"command",
+	"system",
+	"tool",
+	"policy",
+	"subagent_status",
+	"legacy_log"
+]);
+async function handleAdapterCommand(content, config, trpcClient, chatId) {
+	const trimmed = content.trim();
+	if (trimmed === "/show all") {
+		const newConfig = { filters: { ...config.filters } };
+		for (const role of VALID_ROLES) newConfig.filters[role] = true;
+		return {
+			type: "text",
+			text: "Configuration updated: Showing all messages.",
+			newConfig
+		};
+	}
+	if (trimmed === "/hide all") return {
+		type: "text",
+		text: "Configuration updated: Hidden all overrides (using defaults).",
+		newConfig: { filters: {} }
+	};
+	if (trimmed === "/show" || trimmed === "/hide") return {
+		type: "text",
+		text: `Valid options for ${trimmed}: ${Array.from(VALID_ROLES).join(", ")}`
+	};
+	if (trimmed.startsWith("/show ")) {
+		const role = trimmed.slice(6).trim();
+		if (!VALID_ROLES.has(role)) return {
+			type: "text",
+			text: `Error: '${role}' is not a valid message role or special value. Valid options: ${Array.from(VALID_ROLES).join(", ")}`
+		};
+		return {
+			type: "text",
+			text: `Configuration updated: Showing messages for '${role}'.`,
+			newConfig: { filters: {
+				...config.filters,
+				[role]: true
+			} }
+		};
+	}
+	if (trimmed.startsWith("/hide ")) {
+		const role = trimmed.slice(6).trim();
+		if (!VALID_ROLES.has(role)) return {
+			type: "text",
+			text: `Error: '${role}' is not a valid message role or special value. Valid options: ${Array.from(VALID_ROLES).join(", ")}`
+		};
+		return {
+			type: "text",
+			text: `Configuration updated: Hiding messages for '${role}'.`,
+			newConfig: { filters: {
+				...config.filters,
+				[role]: false
+			} }
+		};
+	}
+	if (trimmed === "/debug" || trimmed.startsWith("/debug ")) {
+		const match = trimmed.match(/^\/debug\s+(\d+)$/);
+		const limit = match ? parseInt(match[1], 10) : 5;
+		const messages = await trpcClient.getMessages.query({
+			chatId,
+			limit: limit * 10
+		});
+		const ignoredMessages = [];
+		for (let i = messages.length - 1; i >= 0; i--) {
+			const msg = messages[i];
+			if (!msg) continue;
+			if ((msg.role === "user" || msg.displayRole === "user") && !msg.subagentId) continue;
+			if (!shouldDisplayMessage(msg, config)) {
+				ignoredMessages.push(msg);
+				if (ignoredMessages.length >= limit) break;
+			}
+		}
+		ignoredMessages.reverse();
+		return {
+			type: "debug",
+			messages: ignoredMessages
+		};
+	}
+	return null;
+}
+
+//#endregion
+//#region src/shared/adapters/routing.ts
+async function handleRoutingCommand(content, externalContextId, currentChannelChatMap, adapterName, trpcClient) {
+	const trimmed = content.trim();
+	if (trimmed.startsWith("/chat")) {
+		const chatId = trimmed.split(/\s+/).slice(1)[0];
+		const availableChats = await trpcClient.getChats.query();
+		if (!chatId || !availableChats.includes(chatId)) return {
+			type: "reply",
+			text: `Available chats:\n${availableChats.length > 0 ? availableChats.map((c) => `- ${c}`).join("\n") : "No chats available."}\n\nPlease specify a valid chat ID: \`/chat [chat-id]\``
+		};
+		for (const [channelId, mappedId] of Object.entries(currentChannelChatMap)) if (mappedId === chatId && channelId !== externalContextId) return {
+			type: "reply",
+			text: `Error: Chat \`${chatId}\` is already mapped to another channel/space. Strict 1:1 mapping is required.`
+		};
+		return {
+			type: "mapped",
+			text: `Successfully mapped this channel/space to chat \`${chatId}\`.`,
+			newChatId: chatId
+		};
+	}
+	if (trimmed.startsWith("/agent")) {
+		const agentId = trimmed.split(/\s+/).slice(1)[0];
+		const availableAgents = await trpcClient.getAgents.query();
+		if (!agentId || !availableAgents.includes(agentId)) return {
+			type: "reply",
+			text: `Available agents:\n${availableAgents.length > 0 ? availableAgents.map((a) => `- ${a}`).join("\n") : "No agents available."}\n\nPlease specify a valid agent ID: \`/agent [agent-id]\``
+		};
+		const availableChats = await trpcClient.getChats.query();
+		let newChatId = `${agentId}-${adapterName}`;
+		let counter = 1;
+		while (availableChats.includes(newChatId)) {
+			newChatId = `${agentId}-${adapterName}-${counter}`;
+			counter++;
+		}
+		await trpcClient.createChat.mutate({
+			chatId: newChatId,
+			agent: agentId
+		});
+		return {
+			type: "mapped",
+			text: `Successfully created new chat \`${newChatId}\` with agent \`${agentId}\` and mapped it to this channel/space.`,
+			newChatId
+		};
+	}
+	return null;
+}
+
+//#endregion
+//#region src/shared/adapters/blockquote.ts
+/**
+* Format `quoted` as a markdown blockquote prefixed before `body`.
+*
+* Each line of `quoted` is prefixed with `> `, and a blank line separates the
+* quote from the body — CommonMark requires the blank line to terminate the
+* blockquote, otherwise the body is lazily folded into it. If `sender` is
+* provided, an attribution line (`> **{sender} said:**`) is rendered as the
+* first line of the quote. Both inputs are trimmed.
+*/
+function prependBlockquote(quoted, body, sender) {
+	const trimmedBody = body.trim();
+	const lines = quoted.trim().split("\n").map((line) => `> ${line}`);
+	if (sender) lines.unshift(`> **${sender} said:**`);
+	return `${lines.join("\n")}\n\n${trimmedBody}`;
+}
+
+//#endregion
+//#region src/shared/event-source.ts
+function createUnixSocketEventSource(socketPath) {
+	return class UnixSocketEventSource {
+		readyState = 0;
+		CONNECTING = 0;
+		OPEN = 1;
+		CLOSED = 2;
+		req = null;
+		listeners = {};
+		constructor(url, init) {
+			const parsedUrl = new URL(url);
+			const options = {
+				socketPath,
+				path: parsedUrl.pathname + parsedUrl.search,
+				method: "GET",
+				headers: {
+					Accept: "text/event-stream",
+					"Cache-Control": "no-cache",
+					...init?.headers
+				}
+			};
+			this.req = http.request(options, (res) => {
+				if (res.statusCode === 200) {
+					this.readyState = this.OPEN;
+					this.dispatchEvent({ type: "open" });
+				} else {
+					this.readyState = this.CLOSED;
+					this.dispatchEvent({
+						type: "error",
+						message: `Unexpected status code: ${res.statusCode}`
+					});
+					return;
+				}
+				let buffer = "";
+				res.on("data", (chunk) => {
+					buffer += chunk.toString("utf-8");
+					const lines = buffer.split(/\r?\n\r?\n/);
+					buffer = lines.pop() || "";
+					for (const block of lines) this.parseBlock(block);
+				});
+				res.on("end", () => {
+					if (buffer) this.parseBlock(buffer);
+					this.readyState = this.CLOSED;
+					this.dispatchEvent({ type: "close" });
+				});
+			});
+			this.req.on("error", (err) => {
+				this.readyState = this.CLOSED;
+				this.dispatchEvent({
+					type: "error",
+					error: err
+				});
+			});
+			this.req.end();
+		}
+		parseBlock(block) {
+			if (!block.trim()) return;
+			const lines = block.split(/\r?\n/);
+			let eventType = "message";
+			let data = "";
+			let id = "";
+			for (const line of lines) if (line.startsWith("event: ")) eventType = line.slice(7).trim();
+			else if (line.startsWith("data: ")) data += (data ? "\n" : "") + line.slice(6);
+			else if (line.startsWith("id: ")) id = line.slice(4).trim();
+			if (data) this.dispatchEvent({
+				type: eventType,
+				data,
+				lastEventId: id
+			});
+		}
+		addEventListener(type, listener) {
+			if (!this.listeners[type]) this.listeners[type] = [];
+			this.listeners[type].push(listener);
+		}
+		removeEventListener(type, listener) {
+			if (!this.listeners[type]) return;
+			this.listeners[type] = this.listeners[type].filter((l) => l !== listener);
+		}
+		dispatchEvent(event) {
+			const type = event.type;
+			if (this.listeners[type]) for (const listener of this.listeners[type]) listener(event);
+		}
+		close() {
+			this.readyState = this.CLOSED;
+			if (this.req) this.req.destroy();
+		}
+	};
+}
+
+//#endregion
+//#region src/shared/adapters/turn-log.ts
+const DEFAULT_MAX_TOOL_PREVIEW = 400;
+const TRUNCATED_SUFFIX = "…[truncated]";
+const ROLLOVER_MARKER = "• …log continues";
+function pad2(n) {
+	return n < 10 ? `0${n}` : String(n);
+}
+function formatRelative(deltaMs) {
+	const sec = Math.max(0, Math.floor(deltaMs / 1e3));
+	if (sec < 60) return `${sec}s`;
+	const m = Math.floor(sec / 60);
+	const s = sec % 60;
+	return s === 0 ? `${m}m` : `${m}m${s}s`;
+}
+function formatTimestamp(iso, turnStartedAt) {
+	if (turnStartedAt) {
+		const start = new Date(turnStartedAt).getTime();
+		const now = iso ? new Date(iso).getTime() : Date.now();
+		if (!Number.isNaN(start) && !Number.isNaN(now)) return formatRelative(now - start);
+	}
+	const d = iso ? new Date(iso) : /* @__PURE__ */ new Date();
+	const valid = !Number.isNaN(d.getTime()) ? d : /* @__PURE__ */ new Date();
+	return `${pad2(valid.getHours())}:${pad2(valid.getMinutes())}:${pad2(valid.getSeconds())}`;
+}
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function shortSubagentId(id) {
+	return UUID_RE.test(id) ? id.slice(0, 8) : id;
+}
+/**
+* Extract a (verb, principal-arg) pair from a tool message so the turn log
+* can render `read: foo.md` instead of `read_file({ "file_path": "foo.md" })`.
+* Unknown tool names fall back to `<name>: <stringified-payload>` so we don't
+* silently lose information.
+*/
+function extractToolPrincipal(name, payload) {
+	const p = payload ?? {};
+	const str = (v) => v == null ? "" : String(v);
+	switch (name) {
+		case "read_file":
+		case "Read": return {
+			verb: "read",
+			arg: str(p.file_path ?? p.path)
+		};
+		case "write_file":
+		case "create_file":
+		case "Write": return {
+			verb: "write",
+			arg: str(p.file_path ?? p.path)
+		};
+		case "edit_file":
+		case "Edit": return {
+			verb: "edit",
+			arg: str(p.file_path ?? p.path)
+		};
+		case "run_shell_command":
+		case "shell":
+		case "Bash": return {
+			verb: "shell",
+			arg: str(p.command)
+		};
+		case "activate_skill":
+		case "Skill": return {
+			verb: "skill",
+			arg: str(p.name ?? p.skill)
+		};
+		case "glob":
+		case "Glob": return {
+			verb: "glob",
+			arg: str(p.pattern)
+		};
+		case "grep":
+		case "Grep": return {
+			verb: "grep",
+			arg: str(p.pattern)
+		};
+		case "web_fetch":
+		case "WebFetch": return {
+			verb: "fetch",
+			arg: str(p.url)
+		};
+	}
+	return {
+		verb: name,
+		arg: payload === void 0 || payload === null ? "" : JSON.stringify(payload)
+	};
+}
+function statusSigil(status) {
+	return status === "completed" ? "✅" : "❌";
+}
+/** Emoji for messages crossing the subagent boundary. */
+const SUBAGENT_TO = "👉";
+const SUBAGENT_FROM = "👈";
+/**
+* Emoji that stands in for a known tool verb. When present, it replaces the
+* verb word entirely (`🐚 sleep 20` instead of `shell: sleep 20`). Unknown
+* tools fall through to the `<name>: <arg>` form, preserving accessibility.
+*/
+const VERB_EMOJI = {
+	read: "📖",
+	write: "✍️",
+	edit: "✏️",
+	shell: "🧑‍💻",
+	skill: "📚",
+	glob: "📁",
+	grep: "🔎",
+	fetch: "🌐"
+};
+const SUBAGENT_MARKER = "🤖";
+/** Emoji rendered on the turn's opening entry (posted when the turn starts). */
+const TURN_START_EMOJI = "▶️";
+/**
+* Entries produced *inside* a subagent (a tool call, policy, system event
+* with `subagentId` set) need a marker so the reader knows the activity
+* happened inside the delegated turn. Boundary events (prompt, reply, status)
+* already name the subagent via 👉/👈/✅, so they're excluded.
+*/
+function needsSubagentMarker(entry) {
+	if (!entry.subagentId) return false;
+	return entry.messageRole !== "user" && entry.messageRole !== "agent" && entry.messageRole !== "subagent_status";
+}
+function truncate(s, max) {
+	if (s.length <= max) return s;
+	const budget = Math.max(0, max - 12);
+	return s.slice(0, budget) + TRUNCATED_SUFFIX;
+}
+function sanitize(s) {
+	return s.replace(/\s*\r?\n\s*/g, " ").trim();
+}
+function renderEntry(entry) {
+	const prefix = needsSubagentMarker(entry) ? `${SUBAGENT_MARKER} ${shortSubagentId(entry.subagentId)} ` : "";
+	return `• ${entry.timestamp}  ${prefix}${entry.summary}`;
+}
+/**
+* Build the first entry posted into a turn's activity log so the thread
+* appears as soon as `turnStarted` fires, rather than waiting for the first
+* real event.
+*/
+function buildTurnStartEntry() {
+	const summary = `${TURN_START_EMOJI} Started processing…`;
+	return {
+		timestamp: "0s",
+		kind: "system",
+		summary,
+		rawLength: summary.length,
+		messageRole: "turn_start"
+	};
+}
+function formatTurnLogEntry(message, opts = {}) {
+	const maxToolPreview = opts.maxToolPreview ?? DEFAULT_MAX_TOOL_PREVIEW;
+	const timestamp = formatTimestamp(message.timestamp, opts.turnStartedAt);
+	if (message.role === "user" || message.role === "agent") {
+		if (!message.subagentId) return null;
+		const direction = message.role === "user" ? SUBAGENT_TO : SUBAGENT_FROM;
+		const content = sanitize(message.content);
+		return {
+			timestamp,
+			kind: "subagent",
+			summary: `${direction} ${shortSubagentId(message.subagentId)}: ${truncate(content, maxToolPreview)}`,
+			rawLength: content.length,
+			messageRole: message.role,
+			subagentId: message.subagentId
+		};
+	}
+	if (message.role === "tool") {
+		const { verb, arg } = extractToolPrincipal(message.name, message.payload);
+		const cleanArg = sanitize(arg);
+		const emoji = VERB_EMOJI[verb];
+		const argPreview = cleanArg ? truncate(cleanArg, maxToolPreview) : "";
+		let summary;
+		if (emoji) summary = argPreview ? `${emoji} ${argPreview}` : emoji;
+		else summary = argPreview ? `${verb}: ${argPreview}` : verb;
+		const entry = {
+			timestamp,
+			kind: "tool",
+			summary,
+			rawLength: cleanArg.length,
+			messageRole: message.role
+		};
+		if (message.subagentId) entry.subagentId = message.subagentId;
+		return entry;
+	}
+	if (message.role === "subagent_status") {
+		const id = shortSubagentId(message.subagentId);
+		const summary = `${statusSigil(message.status)} ${id}`;
+		return {
+			timestamp,
+			kind: "subagent",
+			summary,
+			rawLength: summary.length,
+			messageRole: message.role,
+			subagentId: message.subagentId
+		};
+	}
+	if (message.role === "policy") {
+		const body = `${message.commandName} ${message.args.join(" ")}`.trim();
+		const summary = `policy ${message.status}: ${body}`;
+		const entry = {
+			timestamp,
+			kind: "policy",
+			summary: truncate(sanitize(summary), maxToolPreview),
+			rawLength: summary.length,
+			messageRole: message.role
+		};
+		if (message.subagentId) entry.subagentId = message.subagentId;
+		return entry;
+	}
+	if (message.role === "system") {
+		if (message.event === "subagent_update") return null;
+		const content = sanitize(message.content || "");
+		const summary = content ? `${message.event}: ${content}` : message.event;
+		const entry = {
+			timestamp,
+			kind: "system",
+			summary: truncate(summary, maxToolPreview),
+			rawLength: summary.length,
+			messageRole: message.role
+		};
+		if (message.subagentId) entry.subagentId = message.subagentId;
+		return entry;
+	}
+	if (message.role === "command") return null;
+	if (message.role === "legacy_log") {
+		const content = sanitize(message.content);
+		const entry = {
+			timestamp,
+			kind: "system",
+			summary: truncate(content ? `log: ${content}` : "log", maxToolPreview),
+			rawLength: content.length,
+			messageRole: message.role
+		};
+		if (message.subagentId) entry.subagentId = message.subagentId;
+		return entry;
+	}
+	return null;
+}
+function joinLines(entries) {
+	return entries.map(renderEntry).join("\n");
+}
+function condenseTurnLog(entries, opts) {
+	const snapshot = entries.slice();
+	if (snapshot.length === 0) return {
+		kind: "fits",
+		text: ""
+	};
+	const fullText = joinLines(snapshot);
+	if (fullText.length <= opts.maxChars) return {
+		kind: "fits",
+		text: fullText
+	};
+	const budget = Math.max(0, opts.maxChars - 17);
+	const kept = [];
+	let runningLength = 0;
+	for (let i = 0; i < snapshot.length; i++) {
+		const line = renderEntry(snapshot[i]);
+		const next = runningLength === 0 ? line.length : runningLength + 1 + line.length;
+		if (next > budget) {
+			if (kept.length === 0) return {
+				kind: "rollover",
+				finalText: truncate(line, opts.maxChars),
+				carryEntries: snapshot.slice(i + 1)
+			};
+			const carryEntries = snapshot.slice(i);
+			return {
+				kind: "rollover",
+				finalText: `${joinLines(kept)}\n${ROLLOVER_MARKER}`,
+				carryEntries
+			};
+		}
+		runningLength = next;
+		kept.push(snapshot[i]);
+	}
+	return {
+		kind: "fits",
+		text: fullText
+	};
+}
+
+//#endregion
+//#region src/shared/adapters/turn-log-buffer.ts
+function createTurnLogBuffer(deps) {
+	const { options, threadsEnabled, postThreaded, editThreaded, isMissingMessageError } = deps;
+	const ctxs = /* @__PURE__ */ new Map();
+	const engaged = (ctx) => threadsEnabled && !ctx.threadsDisabled && !ctx.aborted;
+	const runFlush = async (ctx) => {
+		if (!engaged(ctx)) {
+			ctx.entries = [];
+			return;
+		}
+		if (ctx.anchor === void 0) return;
+		if (ctx.entries.length === 0) return;
+		let result = condenseTurnLog(ctx.entries, { maxChars: options.maxLogMessageChars });
+		const send = async () => {
+			const text = result.kind === "fits" ? result.text : result.finalText;
+			if (!ctx.activityLogMessageId) {
+				try {
+					const id = await postThreaded(ctx.anchor, text);
+					if (id) ctx.activityLogMessageId = id;
+				} catch (err) {
+					console.error(`Failed to open thread-log for turn ${ctx.turnId}; dropping further thread-log events for this turn.`, err);
+					ctx.aborted = true;
+					ctx.entries = [];
+				}
+				return;
+			}
+			try {
+				await editThreaded(ctx.anchor, ctx.activityLogMessageId, text);
+			} catch (err) {
+				if (isMissingMessageError(err)) {
+					console.warn("Log message missing on edit — opening a fresh log message.");
+					ctx.activityLogMessageId = void 0;
+					try {
+						const id = await postThreaded(ctx.anchor, text);
+						if (id) ctx.activityLogMessageId = id;
+					} catch (innerErr) {
+						console.error("Failed to re-open log message after missing edit:", innerErr);
+						ctx.activityLogMessageId = void 0;
+					}
+				} else {
+					await new Promise((resolve) => setTimeout(resolve, 500));
+					try {
+						await editThreaded(ctx.anchor, ctx.activityLogMessageId, text);
+					} catch (retryErr) {
+						console.warn("Edit failed twice — finalizing log message.", retryErr);
+						ctx.activityLogMessageId = void 0;
+					}
+				}
+			}
+		};
+		await send();
+		while (!ctx.aborted && result.kind === "rollover") {
+			const prevLen = ctx.entries.length;
+			ctx.entries = result.carryEntries.slice();
+			ctx.activityLogMessageId = void 0;
+			if (ctx.entries.length === 0) break;
+			if (ctx.entries.length >= prevLen) {
+				console.warn(`Turn-log entry larger than maxLogMessageChars — dropping head for turn ${ctx.turnId}`);
+				ctx.entries = ctx.entries.slice(1);
+				if (ctx.entries.length === 0) break;
+			}
+			result = condenseTurnLog(ctx.entries, { maxChars: options.maxLogMessageChars });
+			await send();
+		}
+	};
+	const enqueueFlush = (ctx) => {
+		ctx.flushChain = ctx.flushChain.then(() => runFlush(ctx)).catch((err) => console.error("Flush error:", err));
+	};
+	const scheduleFlush = (ctx) => {
+		if (!engaged(ctx)) return;
+		if (ctx.editTimer) return;
+		ctx.editTimer = setTimeout(() => {
+			ctx.editTimer = null;
+			enqueueFlush(ctx);
+		}, options.editDebounceMs);
+	};
+	return {
+		start(params) {
+			const ctx = {
+				turnId: params.turnId,
+				threadsDisabled: params.threadsDisabled,
+				startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				anchor: params.anchorThread,
+				activityLogMessageId: void 0,
+				entries: threadsEnabled && !params.threadsDisabled ? [buildTurnStartEntry()] : [],
+				editTimer: null,
+				flushChain: Promise.resolve(),
+				aborted: false
+			};
+			ctxs.set(params.turnId, ctx);
+			if (ctx.anchor !== void 0 && engaged(ctx)) enqueueFlush(ctx);
+		},
+		append(turnId, message) {
+			const ctx = ctxs.get(turnId);
+			if (!ctx) return;
+			if (!engaged(ctx)) return;
+			const entry = formatTurnLogEntry(message, {
+				maxToolPreview: options.maxToolPreview,
+				turnStartedAt: ctx.startedAt
+			});
+			if (!entry) return;
+			ctx.entries.push(entry);
+			if (ctx.anchor !== void 0) scheduleFlush(ctx);
+		},
+		assignAnchor(turnId, anchor) {
+			const ctx = ctxs.get(turnId);
+			if (!ctx) return;
+			if (ctx.anchor !== void 0) return;
+			ctx.anchor = anchor;
+			if (engaged(ctx) && ctx.entries.length > 0) enqueueFlush(ctx);
+		},
+		async end(turnId) {
+			const ctx = ctxs.get(turnId);
+			if (!ctx) return;
+			if (ctx.editTimer) {
+				clearTimeout(ctx.editTimer);
+				ctx.editTimer = null;
+			}
+			enqueueFlush(ctx);
+			try {
+				await ctx.flushChain;
+			} catch (err) {
+				console.error("Final flush error:", err);
+			}
+			ctxs.delete(turnId);
+		},
+		has(turnId) {
+			return ctxs.has(turnId);
+		},
+		isAnchored(turnId) {
+			return ctxs.get(turnId)?.anchor !== void 0;
+		},
+		threadsDisabledFor(turnId) {
+			return ctxs.get(turnId)?.threadsDisabled ?? false;
+		},
+		shutdown() {
+			for (const ctx of ctxs.values()) if (ctx.editTimer) clearTimeout(ctx.editTimer);
+			ctxs.clear();
+		}
+	};
+}
+
+//#endregion
+export { handleAdapterCommand as a, routeMessage as c, handleRoutingCommand as i, createUnixSocketEventSource as n, createInboundCache as o, prependBlockquote as r, formatMessage as s, createTurnLogBuffer as t };
+//# sourceMappingURL=turn-log-buffer-DRgW53gl.mjs.map