@gajae-code/coding-agent 0.11.1 → 0.11.3

package/src/sdk/bus/rich-document.ts

@@ -0,0 +1,258 @@
+import { Marked, type Token, type Tokens } from "marked";
+
+export type RichEligibility = { kind: "eligible" } | { kind: "ineligible" };
+
+type MathToken = Token & { type: "btw_math"; expression: string };
+
+const MAX_SCALARS = 32_768;
+const MAX_UTF8_BYTES = 131_072;
+const MAX_BLOCKS = 500;
+const MAX_DEPTH = 16;
+const MAX_TABLE_COLUMNS = 20;
+function exceedsScalarLimit(source: string): boolean {
+	let count = 0;
+	for (const _scalar of source) {
+		count++;
+		if (count > MAX_SCALARS) return true;
+	}
+	return false;
+}
+
+function isEscaped(source: string, index: number): boolean {
+	let escapes = 0;
+	for (let cursor = index - 1; cursor >= 0 && source[cursor] === "\\"; cursor--) escapes++;
+	return escapes % 2 === 1;
+}
+function isPlainTextSafe(source: string): boolean {
+	for (let index = 0; index < source.length; index++) {
+		if (
+			!isEscaped(source, index) &&
+			(source[index] === "*" ||
+				source[index] === "_" ||
+				source[index] === "~" ||
+				source[index] === "`" ||
+				source[index] === "[" ||
+				source[index] === "]" ||
+				source[index] === "<" ||
+				source[index] === ">")
+		)
+			return false;
+	}
+	return true;
+}
+
+function hasLoneSurrogate(source: string): boolean {
+	for (let index = 0; index < source.length; index++) {
+		const code = source.charCodeAt(index);
+		if (code >= 0xd800 && code <= 0xdbff) {
+			if (
+				index + 1 >= source.length ||
+				source.charCodeAt(index + 1) < 0xdc00 ||
+				source.charCodeAt(index + 1) > 0xdfff
+			)
+				return true;
+			index++;
+		} else if (code >= 0xdc00 && code <= 0xdfff) {
+			return true;
+		}
+	}
+	return false;
+}
+
+function hasUnescapedDollar(source: string): boolean {
+	for (let cursor = 0; cursor < source.length; cursor++) {
+		if (source[cursor] === "$" && !isEscaped(source, cursor)) return true;
+	}
+	return false;
+}
+
+function isValidMathExpression(expression: string, multiline: boolean): boolean {
+	return (
+		expression.trim().length > 0 &&
+		(multiline || !expression.includes("\n")) &&
+		!expression.startsWith(" ") &&
+		!expression.endsWith(" ") &&
+		!hasUnescapedDollar(expression) &&
+		!expression.includes("\\(") &&
+		!expression.includes("\\)") &&
+		!expression.includes("\\[") &&
+		!expression.includes("\\]")
+	);
+}
+
+function validateInlineMath(source: string): boolean {
+	for (let cursor = 0; cursor < source.length; cursor++) {
+		if (source[cursor] === "$" && !isEscaped(source, cursor)) {
+			if (source[cursor + 1] === "$") return false;
+			let closing = cursor + 1;
+			while (closing < source.length && (source[closing] !== "$" || isEscaped(source, closing))) closing++;
+			if (closing === source.length || !isValidMathExpression(source.slice(cursor + 1, closing), false))
+				return false;
+			cursor = closing;
+			continue;
+		}
+		if (source.startsWith("\\(", cursor) && !isEscaped(source, cursor)) {
+			let closing = cursor + 2;
+			while (closing < source.length && (!source.startsWith("\\)", closing) || isEscaped(source, closing)))
+				closing++;
+			if (closing === source.length || !isValidMathExpression(source.slice(cursor + 2, closing), false))
+				return false;
+			cursor = closing + 1;
+			continue;
+		}
+		if (source.startsWith("\\)", cursor) && !isEscaped(source, cursor)) return false;
+		if ((source.startsWith("\\[", cursor) || source.startsWith("\\]", cursor)) && !isEscaped(source, cursor))
+			return false;
+	}
+	return true;
+}
+
+function parseDisplayMath(source: string): boolean {
+	const block = source.trim();
+	const delimiter =
+		block.startsWith("$$") && block.endsWith("$$")
+			? "$$"
+			: block.startsWith("\\[") && block.endsWith("\\]")
+				? "\\["
+				: undefined;
+	if (delimiter === undefined) return false;
+	const closing = delimiter === "$$" ? "$$" : "\\]";
+	return (
+		!isEscaped(block, block.length - closing.length) &&
+		isValidMathExpression(block.slice(delimiter.length, -closing.length).trim(), true)
+	);
+}
+
+const marked = new Marked({
+	async: false,
+	breaks: false,
+	gfm: true,
+	pedantic: false,
+	silent: false,
+	extensions: [
+		{
+			name: "btw_math",
+			level: "inline",
+			start(src) {
+				const dollar = src.indexOf("$");
+				const parenthesized = src.indexOf("\\(");
+				if (dollar < 0) return parenthesized;
+				if (parenthesized < 0) return dollar;
+				return Math.min(dollar, parenthesized);
+			},
+			tokenizer(src) {
+				if (src.startsWith("$") && !src.startsWith("$$")) {
+					let closing = 1;
+					while (closing < src.length && (src[closing] !== "$" || isEscaped(src, closing))) closing++;
+					const expression = src.slice(1, closing);
+					if (closing < src.length && isValidMathExpression(expression, false))
+						return { type: "btw_math", raw: src.slice(0, closing + 1), expression };
+				}
+				if (src.startsWith("\\(")) {
+					let closing = 2;
+					while (closing < src.length && (!src.startsWith("\\)", closing) || isEscaped(src, closing))) closing++;
+					const expression = src.slice(2, closing);
+					if (closing < src.length && isValidMathExpression(expression, false))
+						return { type: "btw_math", raw: src.slice(0, closing + 2), expression };
+				}
+				return undefined;
+			},
+		},
+	],
+});
+
+function recognizeText(tokens: Token[], depth: number): boolean {
+	if (depth > MAX_DEPTH) return false;
+	for (const token of tokens) {
+		switch (token.type) {
+			case "btw_math":
+				if (depth > 2 || !isValidMathExpression((token as MathToken).expression, false)) return false;
+				break;
+			case "text":
+				if (!isPlainTextSafe(token.raw)) return false;
+				break;
+			case "escape":
+			case "br":
+			case "codespan":
+				break;
+			case "strong":
+			case "em":
+			case "del":
+				if (token.tokens === undefined || !recognizeText(token.tokens, depth + 1)) return false;
+				break;
+			default:
+				return false;
+		}
+	}
+	return true;
+}
+
+function recognizeTable(token: Tokens.Table, count: { value: number }): boolean {
+	const columns = token.header.length;
+	if (
+		columns < 1 ||
+		columns > MAX_TABLE_COLUMNS ||
+		token.align.length !== columns ||
+		token.rows.some(row => row.length !== columns) ||
+		token.align.some(align => align !== "left" && align !== "center" && align !== "right" && align !== null)
+	)
+		return false;
+	for (const row of [token.header, ...token.rows]) {
+		for (const cell of row) {
+			if (!validateInlineMath(cell.text) || !recognizeText(cell.tokens, 0)) return false;
+		}
+	}
+	count.value += 1 + token.rows.length + 1;
+	return count.value <= MAX_BLOCKS;
+}
+
+/** Conservatively recognize `/btw` Markdown that can be represented as rich content. */
+export function parseRichEligibility(markdown: string): RichEligibility {
+	try {
+		if (
+			hasLoneSurrogate(markdown) ||
+			exceedsScalarLimit(markdown) ||
+			Buffer.byteLength(markdown, "utf8") > MAX_UTF8_BYTES ||
+			markdown.includes("\u0000")
+		)
+			return { kind: "ineligible" };
+
+		const tokens = marked.lexer(markdown);
+		const count = { value: 0 };
+		let structured = false;
+		for (const token of tokens) {
+			if (token.type === "space") continue;
+			if (token.type === "heading") {
+				if (
+					token.tokens === undefined ||
+					token.depth < 1 ||
+					token.depth > 6 ||
+					!validateInlineMath(token.text) ||
+					!recognizeText(token.tokens, 0)
+				)
+					return { kind: "ineligible" };
+				count.value++;
+			} else if (token.type === "paragraph" || token.type === "text") {
+				if (token.type === "paragraph" && parseDisplayMath(token.text)) {
+					structured = true;
+					count.value++;
+				} else {
+					const inline = token.type === "paragraph" ? token.tokens : [token];
+					if (inline === undefined || !validateInlineMath(token.text) || !recognizeText(inline, 0))
+						return { kind: "ineligible" };
+					structured ||= inline.some(part => part.type === "btw_math");
+					count.value++;
+				}
+			} else if (token.type === "table") {
+				if (!recognizeTable(token as Tokens.Table, count)) return { kind: "ineligible" };
+				structured = true;
+			} else {
+				return { kind: "ineligible" };
+			}
+			if (count.value > MAX_BLOCKS) return { kind: "ineligible" };
+		}
+		return structured ? { kind: "eligible" } : { kind: "ineligible" };
+	} catch {
+		return { kind: "ineligible" };
+	}
+}

package/src/sdk/bus/rich-render.ts

@@ -2,28 +2,20 @@
  * Rich-message promotion for stable non-editable Telegram text sends.
  *
  * When enabled, the daemon promotes eligible finalized `sendMessage` payloads
- * carrying raw markdown to the Bot API `sendRichMessage` method. On any miss or
- * failure the daemon keeps the unchanged HTML `sendMessage` path, so the
- * off-state request bodies are byte-identical.
+ * carrying raw markdown to Bot API `sendRichMessage`. Only an explicit
+ * `{ ok: false }` response selects the unchanged HTML path; ambiguous transport
+ * outcomes remain single-attempt and never fall back.
  */
 
+import { parseRichEligibility } from "./rich-document";
 import type { BotApi } from "./telegram-daemon";
 import type { ThreadedSend } from "./threaded-render";
 
 /**
- * Telegram's hard per-message character ceiling (4096). Surfaced here purely as
- * documentation and a marker for a future native rich-message splitter — it is
- * intentionally NON-BEHAVIORAL and MUST stay that way: nothing in the rich path
- * branches on this value.
- *
- * Overflow is already safe without it. The production final-answer text is capped
- * at 3500 chars upstream (`summaryFromMessage(..., 3500)`), so a promoted
- * `sendRichMessage` never approaches this ceiling; and if the Bot API ever rejects
- * an oversized rich payload it returns `{ ok: false }`, which
- * `deliverRichWithFallback` (below) turns into the chunked HTML `splitTelegramHtml`
- * fallback (each chunk ≤ TELEGRAM_MESSAGE_LIMIT). This constant only marks where a
- * future rich splitter would read its ceiling; wiring it into a branch would change
- * byte-for-byte behavior and is out of scope.
+ * Telegram's hard per-message character ceiling (4096). Final-answer promotion
+ * uses this value to keep oversized Markdown on the existing chunked HTML path.
+ * `/btw` eligibility has its own 32,768-scalar route guard; only a definite
+ * rich rejection may select the correlated HTML path.
  */
 export const RICH_MESSAGE_LIMIT = 4096;
 
@@ -31,8 +23,16 @@ export const RICH_MESSAGE_LIMIT = 4096;
 export function buildRichMessage(
 	raw: string,
 	extras: { reply_markup?: unknown } = {},
-): { rich_message: { markdown: string }; reply_markup?: unknown } {
-	return { rich_message: { markdown: raw }, ...extras };
+): { rich_message: { markdown: string; skip_entity_detection: true }; reply_markup?: unknown } {
+	return { rich_message: { markdown: raw, skip_entity_detection: true }, ...extras };
+}
+/** Telegram message identifiers are strictly positive safe integers. */
+function validMessageId(value: unknown): value is number {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+/** Whether `/btw` Markdown may use Bot API 10.1 rich delivery. */
+export function isBtwRichEligible(markdown: string): boolean {
+	return parseRichEligibility(markdown).kind === "eligible";
 }
 
 /**
@@ -56,88 +56,80 @@ export function shouldPromoteRich(input: { enabled?: boolean; send: ThreadedSend
 }
 
 /**
- * Deliver the promoted rich message, falling back to `fallbackDeliver` (the
- * unchanged HTML `sendMessage` loop) on any failure. A failure is either a
- * thrown transport error or a `{ ok: false }` JSON response (the transport
- * returns `res.json()` for JSON methods, so `ok:false` does not throw). On
- * failure exactly one diagnostic is logged before the fallback runs; on success
- * the fallback never runs.
- *
- * Returns the sent message's `message_id` on success (when the response carries
- * one), otherwise `undefined` — including every failure/fallback path and a
- * success whose response omits `result.message_id`. Callers that ignore the
- * return value are unaffected.
+ * Deliver the promoted rich message, falling back to `fallbackDeliver` only
+ * after an explicit `{ ok: false }` response. Transport errors and malformed or
+ * ambiguous responses are logged but never retried or sent again through HTML.
  */
 export async function deliverRichWithFallback(
 	botApi: BotApi,
 	base: { chat_id: string | number; message_thread_id?: number },
 	send: ThreadedSend,
+	signal: AbortSignal,
 	fallbackDeliver: () => Promise<void>,
 	log?: { warn(msg: string): void },
 ): Promise<number | undefined> {
-	let failure: string | undefined;
-	let messageId: number | undefined;
 	try {
-		const res = await botApi.call("sendRichMessage", { ...base, ...buildRichMessage(send.richMarkdown!) });
+		const res = await botApi.call(
+			"sendRichMessage",
+			{ ...base, ...buildRichMessage(send.richMarkdown!) },
+			{ noRetry: true, signal },
+		);
 		if (res !== null && typeof res === "object" && (res as { ok?: unknown }).ok === false) {
 			const description = (res as { description?: unknown }).description;
-			failure = typeof description === "string" && description.length > 0 ? description : "ok:false";
-		} else {
-			const candidate = (res as { result?: { message_id?: unknown } } | null)?.result?.message_id;
-			if (typeof candidate === "number") messageId = candidate;
+			const failure = typeof description === "string" && description.length > 0 ? description : "ok:false";
+			log?.warn(`notifications: sendRichMessage rejected (${failure}); falling back to HTML`);
+			await fallbackDeliver();
+			return undefined;
 		}
+		const candidate = (res as { result?: { message_id?: unknown } } | null)?.result?.message_id;
+		if (validMessageId(candidate)) return candidate;
+		log?.warn("notifications: sendRichMessage outcome ambiguous; not falling back to HTML");
 	} catch (err) {
-		failure = err instanceof Error ? err.message : String(err);
+		const failure = err instanceof Error ? err.message : String(err);
+		log?.warn(`notifications: sendRichMessage failed (${failure}); not falling back to HTML`);
 	}
-	if (failure === undefined) return messageId;
-	log?.warn(`notifications: sendRichMessage failed (${failure}); falling back to HTML`);
-	await fallbackDeliver();
 	return undefined;
 }
 
 /**
  * Deliver an action-needed (ask/idle) message via `sendRichMessage`, falling
- * back to the unchanged HTML chunk loop on any failure. Mirrors
- * {@link deliverRichWithFallback} but takes an explicit markdown body plus an
- * optional top-level `reply_markup` (probe-confirmed: `sendRichMessage` accepts
- * `reply_markup` alongside `rich_message`), and surfaces a structured outcome so
- * the daemon can route inbound replies to the resulting message id.
- *
- * On rich success: returns `{ messageId, usedRich: true, usedFallback: false }`
- * where `messageId` is `res.result.message_id` when present. On a `{ ok:false }`
- * response or a thrown transport error: warns exactly once, runs `htmlFallback`,
- * and returns `{ messageId, usedRich: false, usedFallback: true }` where
- * `messageId` is the fallback's return value (the last HTML chunk's id).
+ * back to the unchanged HTML chunk loop only after an explicit `{ ok:false }`
+ * response. Other outcomes are ambiguous, are logged, and preserve the single
+ * physical rich delivery.
  */
 export async function deliverRichActionWithFallback(
 	botApi: BotApi,
 	base: { chat_id: string | number; message_thread_id?: number },
-	opts: { markdown: string; replyMarkup?: unknown; requireMessageId?: boolean },
+	opts: { markdown: string; replyMarkup?: unknown },
+	signal: AbortSignal,
 	htmlFallback: () => Promise<number | undefined>,
 	log?: { warn(msg: string): void },
 ): Promise<{ messageId?: number; usedRich: boolean; usedFallback: boolean }> {
-	let failure: string | undefined;
-	let messageId: number | undefined;
 	try {
-		const res = await botApi.call("sendRichMessage", {
-			...base,
-			...buildRichMessage(opts.markdown, opts.replyMarkup === undefined ? {} : { reply_markup: opts.replyMarkup }),
-		});
+		const res = await botApi.call(
+			"sendRichMessage",
+			{
+				...base,
+				...buildRichMessage(
+					opts.markdown,
+					opts.replyMarkup === undefined ? {} : { reply_markup: opts.replyMarkup },
+				),
+			},
+			{ noRetry: true, signal },
+		);
 		if (res !== null && typeof res === "object" && (res as { ok?: unknown }).ok === false) {
 			const description = (res as { description?: unknown }).description;
-			failure = typeof description === "string" && description.length > 0 ? description : "ok:false";
-		} else {
-			const candidate = (res as { result?: { message_id?: unknown } } | null)?.result?.message_id;
-			if (typeof candidate === "number") messageId = candidate;
-			// Ask messages MUST be reply-routable: if a rich success carries no numeric
-			// message_id, fall back to HTML so a routable id is guaranteed.
-			else if (opts.requireMessageId) failure = "rich response missing message_id";
+			const failure = typeof description === "string" && description.length > 0 ? description : "ok:false";
+			log?.warn(`notifications: sendRichMessage(action) rejected (${failure}); falling back to HTML`);
+			const fallbackId = await htmlFallback();
+			return { messageId: fallbackId, usedRich: false, usedFallback: true };
 		}
+		const candidate = (res as { result?: { message_id?: unknown } } | null)?.result?.message_id;
+		if (validMessageId(candidate)) return { messageId: candidate, usedRich: true, usedFallback: false };
+		log?.warn("notifications: sendRichMessage(action) outcome ambiguous; not falling back to HTML");
 	} catch (err) {
-		failure = err instanceof Error ? err.message : String(err);
+		const failure = err instanceof Error ? err.message : String(err);
+		log?.warn(`notifications: sendRichMessage(action) failed (${failure}); not falling back to HTML`);
 	}
-	if (failure === undefined) return { messageId, usedRich: true, usedFallback: false };
-	log?.warn(`notifications: sendRichMessage(action) failed (${failure}); falling back to HTML`);
-	const fallbackId = await htmlFallback();
-	return { messageId: fallbackId, usedRich: false, usedFallback: true };
+	return { messageId: undefined, usedRich: true, usedFallback: false };
 }

package/src/sdk/bus/telegram-daemon-cli.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { logger } from "@gajae-code/utils";
 import { YAML } from "bun";
 import { applyAtomicYamlPatches, setByPath } from "../../config/atomic-yaml-patch";
 import type { Settings } from "../../config/settings";
@@ -7,8 +8,7 @@ import {
 	getNotificationConfig,
 	isTelegramConfigured,
 	type NotificationSettingsReader,
-	type NotificationSettingsSnapshot,
-	readTelegramActivationMarkers,
+	parseNotificationSettingsSnapshot,
 } from "./config";
 import { daemonPaths, HEARTBEAT_TTL_MS } from "./daemon-paths";
 import {
@@ -53,68 +53,21 @@ function argValue(argv: string[], name: string): string | undefined {
 	const i = argv.indexOf(name);
 	return i >= 0 ? argv[i + 1] : undefined;
 }
-
-function getByPath(obj: unknown, pathSegments: string[]): unknown {
-	let current = obj;
-	for (const segment of pathSegments) {
-		if (!current || typeof current !== "object" || Array.isArray(current)) return undefined;
-		current = (current as Record<string, unknown>)[segment];
-	}
-	return current;
-}
-
-function asString(value: unknown): string | undefined {
-	return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-
-function asBoolean(value: unknown, fallback: boolean): boolean {
-	return typeof value === "boolean" ? value : fallback;
-}
-
-function asIdleTimeoutMs(value: unknown): number {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 60_000;
+const DAEMON_COMPATIBILITY_DIAGNOSTIC_LIMIT = 1;
+let daemonCompatibilityDiagnosticCount = 0;
+function recordDaemonCompatibilityDiagnostic(message: string): void {
+	if (daemonCompatibilityDiagnosticCount >= DAEMON_COMPATIBILITY_DIAGNOSTIC_LIMIT) return;
+	daemonCompatibilityDiagnosticCount++;
+	logger.warn(message);
 }
 
 export function createLightweightDaemonSettings(input: {
 	agentDir: string;
 	rawConfig?: unknown;
 }): LightweightDaemonSettings {
-	const rawConfig = input.rawConfig && typeof input.rawConfig === "object" ? input.rawConfig : {};
-	const activation = readTelegramActivationMarkers(getByPath(rawConfig, ["notifications", "telegram", "activation"]));
-	const getNotificationSettingsSnapshot = (): NotificationSettingsSnapshot => ({
-		enabled: asBoolean(getByPath(rawConfig, ["notifications", "enabled"]), false),
-		telegram: {
-			botToken: asString(getByPath(rawConfig, ["notifications", "telegram", "botToken"])),
-			chatId: asString(getByPath(rawConfig, ["notifications", "telegram", "chatId"])),
-			...(Object.keys(activation).length === 0 ? {} : { activation }),
-			rich: {
-				enabled: asBoolean(getByPath(rawConfig, ["notifications", "telegram", "rich", "enabled"]), true),
-			},
-			richDraft: {
-				enabled: asBoolean(getByPath(rawConfig, ["notifications", "telegram", "richDraft", "enabled"]), false),
-			},
-			topics: {
-				nameTemplate: asString(getByPath(rawConfig, ["notifications", "telegram", "topics", "nameTemplate"])),
-			},
-		},
-		discord: {
-			botToken: asString(getByPath(rawConfig, ["notifications", "discord", "botToken"])),
-			applicationId: asString(getByPath(rawConfig, ["notifications", "discord", "applicationId"])),
-			guildId: asString(getByPath(rawConfig, ["notifications", "discord", "guildId"])),
-			parentChannelId: asString(getByPath(rawConfig, ["notifications", "discord", "parentChannelId"])),
-		},
-		slack: {
-			botToken: asString(getByPath(rawConfig, ["notifications", "slack", "botToken"])),
-			appToken: asString(getByPath(rawConfig, ["notifications", "slack", "appToken"])),
-			workspaceId: asString(getByPath(rawConfig, ["notifications", "slack", "workspaceId"])),
-			channelId: asString(getByPath(rawConfig, ["notifications", "slack", "channelId"])),
-			authorizedUserId: asString(getByPath(rawConfig, ["notifications", "slack", "authorizedUserId"])),
-		},
-		redact: asBoolean(getByPath(rawConfig, ["notifications", "redact"]), false),
-		verbosity: getByPath(rawConfig, ["notifications", "verbosity"]) === "verbose" ? "verbose" : "lean",
-		sessionScope: getByPath(rawConfig, ["notifications", "sessionScope"]) === "primary" ? "primary" : "all",
-		idleTimeoutMs: asIdleTimeoutMs(getByPath(rawConfig, ["notifications", "daemon", "idleTimeoutMs"])),
-	});
+	const rawConfig = input.rawConfig === undefined ? {} : input.rawConfig;
+	const getNotificationSettingsSnapshot = () => parseNotificationSettingsSnapshot(rawConfig);
+	getNotificationSettingsSnapshot();
 
 	return {
 		get(pathName: string): unknown {
@@ -126,6 +79,8 @@ export function createLightweightDaemonSettings(input: {
 					return snapshot.telegram.botToken;
 				case "notifications.telegram.chatId":
 					return snapshot.telegram.chatId;
+				case "notifications.telegram.btw.enabled":
+					return snapshot.telegram.btw.enabled;
 				case "notifications.discord.botToken":
 					return snapshot.discord.botToken;
 				case "notifications.discord.applicationId":
@@ -243,7 +198,7 @@ export async function runDaemonInternal(argv: string[], deps: RunDaemonInternalD
 	const ownerId = argValue(argv, "--owner-id");
 	if (!ownerId) throw new Error("missing --owner-id");
 	if (!ownerProcessIsAlive(ownerId, deps)) {
-		process.stderr.write(`GJC notify daemon exiting: owner process from --owner-id ${ownerId} is not alive.\n`);
+		recordDaemonCompatibilityDiagnostic("GJC notify daemon exiting because its owner is not alive");
 		return;
 	}
 	const resolvedAgentDir = agentDir ?? process.env.GJC_CODING_AGENT_DIR ?? path.join(process.cwd(), ".gjc", "agent");
@@ -261,6 +216,7 @@ export async function runDaemonInternal(argv: string[], deps: RunDaemonInternalD
 		rich: cfg.rich,
 		richDraft: cfg.richDraft,
 		topics: cfg.topics,
+		btw: cfg.btw,
 		pid: deps.processPid ?? process.pid,
 		control: {
 			shouldStop: async owner => {

package/src/sdk/bus/telegram-daemon-contract.ts

@@ -7,8 +7,13 @@
 export const NOTIFICATION_PROTOCOL_VERSION = 3;
 
 /**
- * Operational generation the current daemon build speaks. It is tied to the
- * wire protocol version so a freshly-upgraded host can identify an older,
- * still-live daemon without coupling status readers to the daemon runtime.
+ * Operational generation the current daemon build speaks. Decoupled from
+ * {@link NOTIFICATION_PROTOCOL_VERSION} (#2304): additive `tool_activity` /
+ * `reasoning_summary` frames do not bump the wire protocol version, but a
+ * freshly-upgraded host must still recognize an older, still-live daemon that
+ * predates capability-gated frame enforcement and trigger a reload. Bump this
+ * on every daemon-behavior change independent of the wire version.
+ * The current development baseline already includes #2299's generation 4;
+ * this behavior change therefore advances the operational generation to 5.
  */
-export const DAEMON_GENERATION = NOTIFICATION_PROTOCOL_VERSION;
+export const DAEMON_GENERATION = 5;