@botcord/daemon 0.2.51 → 0.2.53

package/dist/gateway/channels/http-types.d.ts

@@ -10,10 +10,13 @@
 export type FetchLike = (input: string, init?: {
     method?: string;
     headers?: Record<string, string>;
-    body?: string;
+    body?: BodyInit | Uint8Array | string;
     signal?: AbortSignal;
 }) => Promise<{
     status?: number;
     ok?: boolean;
+    headers?: {
+        get(name: string): string | null;
+    };
     text(): Promise<string>;
 }>;

package/dist/gateway/channels/wechat.js

@@ -1,10 +1,13 @@
+import { basename } from "node:path";
+import { readFile } from "node:fs/promises";
+import { createCipheriv, createHash, randomBytes, randomUUID, } from "node:crypto";
 import { sanitizeUntrustedContent } from "./sanitize.js";
 import { GatewayStateStore } from "./state-store.js";
 import { loadGatewaySecret } from "./secret-store.js";
 import { splitText } from "./text-split.js";
 import { wechatHeaders, WECHAT_BASE_INFO } from "./wechat-http.js";
-import { randomUUID } from "node:crypto";
 const DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
+const DEFAULT_CDN_BASE_URL = "https://novac2c.cdn.weixin.qq.com/c2c";
 /**
  * Replace every occurrence of `token` in `input` with `"[REDACTED]"`.
  * No-ops when token is falsy (not yet loaded).
@@ -149,6 +152,125 @@ export function createWechatChannel(opts) {
             return {};
         }
     }
+    function cdnUploadUrl(resp) {
+        if (typeof resp.upload_full_url === "string" && resp.upload_full_url.length > 0) {
+            return resp.upload_full_url;
+        }
+        if (typeof resp.upload_param === "string" && resp.upload_param.length > 0) {
+            return `${DEFAULT_CDN_BASE_URL}/upload?encrypted_query_param=${encodeURIComponent(resp.upload_param)}`;
+        }
+        return null;
+    }
+    async function uploadEncryptedMedia(trace, attachment) {
+        const raw = attachment.data ??
+            (attachment.filePath ? await readFile(attachment.filePath) : undefined);
+        if (!raw || raw.length === 0) {
+            throw new Error("wechat media upload requires non-empty attachment data or filePath");
+        }
+        const data = Buffer.from(raw);
+        const filename = attachment.filename ??
+            (attachment.filePath ? basename(attachment.filePath) : "attachment");
+        const kind = attachment.kind ?? kindFromContentType(attachment.contentType);
+        const mediaType = kind === "image" ? 1 : kind === "video" ? 2 : 3;
+        const itemType = kind === "image" ? 2 : kind === "video" ? 5 : 4;
+        const aesKey = randomBytes(16);
+        const aesKeyHex = aesKey.toString("hex");
+        const encrypted = encryptAes128Ecb(data, aesKey);
+        const filekey = `botcord-${randomUUID()}`;
+        const uploadResp = await callApi("ilink/bot/getuploadurl", {
+            filekey,
+            media_type: mediaType,
+            to_user_id: trace.fromUserId,
+            rawsize: data.length,
+            rawfilemd5: md5Hex(data),
+            filesize: encrypted.length,
+            aeskey: aesKeyHex,
+            no_need_thumb: true,
+        }, 15_000);
+        if (uploadResp.ret !== 0 && uploadResp.ret !== undefined) {
+            throw new Error(redactSecret(`wechat getuploadurl failed: ret=${uploadResp.ret}`, botToken));
+        }
+        const uploadUrl = cdnUploadUrl(uploadResp);
+        if (!uploadUrl)
+            throw new Error("wechat getuploadurl returned no upload URL");
+        const uploadResult = await fetchImpl(uploadUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/octet-stream" },
+            body: encrypted,
+            signal: AbortSignal.timeout(30_000),
+        });
+        const encryptedParam = uploadResult.headers?.get("x-encrypted-param") ??
+            uploadResult.headers?.get("X-Encrypted-Param") ??
+            (await readEncryptedParamFromBody(uploadResult));
+        if (!encryptedParam) {
+            throw new Error("wechat CDN upload returned no x-encrypted-param");
+        }
+        const media = {
+            encrypt_query_param: encryptedParam,
+            aes_key: Buffer.from(aesKeyHex, "utf8").toString("base64"),
+        };
+        if (itemType === 2) {
+            return {
+                type: itemType,
+                image_item: {
+                    media,
+                    aeskey: aesKeyHex,
+                    mid_size: data.length,
+                },
+            };
+        }
+        if (itemType === 5) {
+            return {
+                type: itemType,
+                video_item: {
+                    media,
+                    video_size: data.length,
+                    file_name: filename,
+                },
+            };
+        }
+        return {
+            type: itemType,
+            file_item: {
+                media,
+                file_name: filename,
+                md5: md5Hex(data),
+                len: data.length,
+            },
+        };
+    }
+    async function readEncryptedParamFromBody(resp) {
+        const raw = await resp.text().catch(() => "");
+        if (!raw)
+            return null;
+        try {
+            const json = JSON.parse(raw);
+            const v = json.encrypted_query_param ?? json.encrypt_query_param ?? json.upload_param;
+            return typeof v === "string" && v.length > 0 ? v : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async function sendItems(trace, items) {
+        const clientId = `botcord-${randomUUID()}`;
+        const body = {
+            msg: {
+                from_user_id: "",
+                to_user_id: trace.fromUserId,
+                client_id: clientId,
+                message_type: 2, // BOT → user
+                message_state: 2, // FINISH
+                context_token: trace.contextToken,
+                item_list: items,
+            },
+        };
+        const resp = await callApi("ilink/bot/sendmessage", body, 15_000);
+        if (resp.ret !== 0 && resp.ret !== undefined) {
+            throw new Error(redactSecret(`wechat sendmessage failed: ret=${resp.ret}`, botToken));
+        }
+        return clientId;
+    }
     function extractText(msg) {
         const parts = [];
         for (const item of msg.item_list ?? []) {
@@ -398,27 +520,23 @@ export function createWechatChannel(opts) {
                 throw new Error(`wechat send: no context_token for traceId=${message.traceId ?? "<missing>"}` +
                     ` (expired or never bound — daemon does not support unsolicited replies)`);
             }
-            const chunks = splitText(message.text, splitAt);
+            const chunks = message.text.length > 0 ? splitText(message.text, splitAt) : [];
             let lastClientId = null;
             for (const chunk of chunks) {
-                const clientId = `botcord-${randomUUID()}`;
-                const body = {
-                    msg: {
-                        from_user_id: "",
-                        to_user_id: trace.fromUserId,
-                        client_id: clientId,
-                        message_type: 2, // BOT → user
-                        message_state: 2, // FINISH
-                        context_token: trace.contextToken,
-                        item_list: [{ type: 1, text_item: { text: chunk } }],
-                    },
-                };
-                const resp = await callApi("ilink/bot/sendmessage", body, 15_000);
-                if (resp.ret !== 0 && resp.ret !== undefined) {
-                    log.warn("wechat sendmessage non-zero ret", { ret: resp.ret });
-                    throw new Error(redactSecret(`wechat sendmessage failed: ret=${resp.ret}`, botToken));
+                lastClientId = await sendItems(trace, [{ type: 1, text_item: { text: chunk } }]);
+            }
+            for (const attachment of message.attachments ?? []) {
+                try {
+                    const item = await uploadEncryptedMedia(trace, attachment);
+                    lastClientId = await sendItems(trace, [item]);
+                }
+                catch (err) {
+                    log.warn("wechat media send failed", {
+                        err: redactSecret(String(err), botToken),
+                        filename: attachment.filename ?? attachment.filePath ?? "attachment",
+                    });
+                    throw err;
                 }
-                lastClientId = clientId;
             }
             const sendAt = Date.now();
             statusSnapshot = { ...statusSnapshot, lastSendAt: sendAt };
@@ -453,6 +571,21 @@ export function createWechatChannel(opts) {
     };
     return adapter;
 }
+function md5Hex(data) {
+    return createHash("md5").update(data).digest("hex");
+}
+function encryptAes128Ecb(data, key) {
+    const cipher = createCipheriv("aes-128-ecb", key, null);
+    cipher.setAutoPadding(true);
+    return Buffer.concat([cipher.update(data), cipher.final()]);
+}
+function kindFromContentType(contentType) {
+    if (contentType?.startsWith("image/"))
+        return "image";
+    if (contentType?.startsWith("video/"))
+        return "video";
+    return "file";
+}
 function sleep(ms, signal) {
     return new Promise((resolve) => {
         if (signal?.aborted) {

package/dist/gateway/types.d.ts

@@ -140,12 +140,22 @@ export type UserTurnBuilder = (message: GatewayInboundMessage) => string;
  */
 export type OutboundObserver = (message: GatewayOutboundMessage) => Promise<void> | void;
 /** Outbound reply payload passed to `ChannelAdapter.send()`. */
+export interface GatewayOutboundAttachment {
+    /** Local daemon-readable file path. */
+    filePath?: string;
+    /** In-memory bytes, primarily for tests and in-process tool callers. */
+    data?: Uint8Array;
+    filename?: string;
+    contentType?: string;
+    kind?: "image" | "file" | "video";
+}
 export interface GatewayOutboundMessage {
     channel: string;
     accountId: string;
     conversationId: string;
     threadId?: string | null;
     text: string;
+    attachments?: GatewayOutboundAttachment[];
     replyTo?: string | null;
     traceId?: string | null;
 }

package/dist/index.js

@@ -172,6 +172,48 @@ function pidAlive(pid) {
         return false;
     }
 }
+async function waitForPidExit(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!pidAlive(pid))
+            return true;
+        await delay(100);
+    }
+    return !pidAlive(pid);
+}
+async function stopExistingDaemonForRestart(pid) {
+    if (pid === process.pid)
+        return;
+    log.info("existing daemon found; restarting", { pid });
+    try {
+        process.kill(pid, "SIGTERM");
+    }
+    catch {
+        try {
+            unlinkSync(PID_PATH);
+        }
+        catch {
+            // ignore
+        }
+        return;
+    }
+    if (!(await waitForPidExit(pid, 5_000))) {
+        log.warn("existing daemon did not stop after SIGTERM; sending SIGKILL", { pid });
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch {
+            // ignore
+        }
+        await waitForPidExit(pid, 2_000);
+    }
+    try {
+        unlinkSync(PID_PATH);
+    }
+    catch {
+        // ignore
+    }
+}
 /**
  * Load the daemon config, auto-creating `~/.botcord/daemon/config.json`
  * with sensible defaults on first run. `--agent` (repeated) pins explicit
@@ -251,6 +293,8 @@ async function redeemInstallToken(opts) {
     const body = { install_token: opts.installToken };
     if (opts.label)
         body.label = opts.label;
+    if (opts.daemonInstanceId)
+        body.daemon_instance_id = opts.daemonInstanceId;
     const resp = await fetch(`${opts.hubUrl.replace(/\/+$/, "")}/daemon/auth/install-token`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
@@ -259,7 +303,9 @@ async function redeemInstallToken(opts) {
     });
     if (!resp.ok) {
         const text = await resp.text().catch(() => "");
-        throw new Error(`daemon install-token redeem failed: ${resp.status} ${text}`);
+        const err = new Error(`daemon install-token redeem failed: ${resp.status} ${text}`);
+        err.status = resp.status;
+        throw err;
     }
     return parseDaemonTokenResponse(await resp.json(), opts.hubUrl);
 }
@@ -330,10 +376,10 @@ async function runDeviceCodeFlow(opts) {
  * plane (legacy P0 behavior — caller may still log a warning).
  *
  * Decision tree (plan §4.4 + §6.4):
- * 1. Have existing creds and no `--relogin` → return existing record, even
- *    when a dashboard `--install-token` is present. The token is one-time and
- *    the generated install command should be safe to re-run after first login.
- * 2. No existing creds + `--install-token` → redeem the one-time dashboard ticket.
+ * 1. `--install-token` → redeem the one-time dashboard ticket. If local
+ *    user-auth exists, include its daemonInstanceId so Hub can re-authorize
+ *    the same device instead of creating a new one.
+ * 2. Have existing creds and no `--relogin` → return existing record.
  * 3. `--relogin` → device-code login.
  * 4. No creds + TTY → device-code login.
  * 5. No creds + no TTY → exit 1 with the §6.4 hint.
@@ -359,22 +405,40 @@ async function ensureUserAuthForStart(args) {
         if (labelFlag && existing.label !== labelFlag) {
             console.error(`note: --label "${labelFlag}" ignored (already logged in as "${existing.label ?? "<unset>"}"); pass --relogin to change it`);
         }
-        if (installToken) {
-            console.error("note: --install-token ignored because daemon is already logged in; pass --relogin to re-bind");
-        }
         return existing;
     }
     // Need a fresh login. Resolve hubUrl: explicit --hub > existing record > DEFAULT_HUB.
     const hubUrl = hubFlag ?? existing?.hubUrl ?? DEFAULT_HUB;
     const label = labelFlag ?? defaultLoginLabel();
     if (authAction === "install-token" && installToken) {
-        const tok = await redeemInstallToken({ hubUrl, installToken, label });
-        const record = userAuthFromTokenResponse(tok, { label });
+        let tok;
+        try {
+            tok = await redeemInstallToken({
+                hubUrl,
+                installToken,
+                label,
+                daemonInstanceId: existing?.daemonInstanceId,
+            });
+        }
+        catch (err) {
+            if (existing && !relogin && !existsSync(AUTH_EXPIRED_FLAG_PATH)) {
+                console.error(`note: --install-token could not be redeemed (${err instanceof Error ? err.message : String(err)}); reusing existing daemon auth`);
+                return existing;
+            }
+            throw err;
+        }
+        const record = userAuthFromTokenResponse(tok, {
+            label,
+            loggedInAt: existing?.daemonInstanceId && existing.daemonInstanceId === tok.daemonInstanceId
+                ? existing.loggedInAt
+                : undefined,
+        });
         saveUserAuth(record);
         clearAuthExpiredFlag();
         log.info("install-token flow: authorized", {
             userId: record.userId,
             daemonInstanceId: record.daemonInstanceId,
+            reusedExistingDaemonInstance: existing?.daemonInstanceId === record.daemonInstanceId,
             hubUrl: record.hubUrl,
             label,
         });
@@ -424,11 +488,6 @@ async function cmdStart(args) {
         relogin: args.flags.relogin === true,
         child: process.env.BOTCORD_DAEMON_CHILD === "1",
     });
-    const existing = readPid();
-    if (existing && pidAlive(existing)) {
-        console.error(`daemon already running (pid ${existing})`);
-        process.exit(1);
-    }
     // Login MUST happen before fork — once detached, stdio is gone and the
     // user can't see the device code. We also run it for explicit
     // --foreground so an interactive user can log in without the fork dance.
@@ -436,6 +495,17 @@ async function cmdStart(args) {
     // var so we don't try to re-prompt for credentials it already has.
     if (process.env.BOTCORD_DAEMON_CHILD !== "1") {
         await ensureUserAuthForStart(args);
+        const existing = readPid();
+        if (existing && pidAlive(existing)) {
+            await stopExistingDaemonForRestart(existing);
+        }
+    }
+    else {
+        const existing = readPid();
+        if (existing && existing !== process.pid && pidAlive(existing)) {
+            console.error(`daemon already running (pid ${existing})`);
+            process.exit(1);
+        }
     }
     if (background) {
         // Detached child re-exec in foreground mode. The child writes the PID

package/dist/openclaw-discovery.js

@@ -3,8 +3,8 @@ import { homedir } from "node:os";
 import path from "node:path";
 import { log as daemonLog } from "./log.js";
 import { probeOpenclawAgents } from "./provision.js";
-const DEFAULT_SEARCH_PATHS = ["~/.openclaw/", "/etc/openclaw/"];
-const DEFAULT_PORTS = [18789, 16200];
+const DEFAULT_SEARCH_PATHS = ["~/.openclaw/", "~/.qclaw/", "/etc/openclaw/"];
+const DEFAULT_PORTS = [18789, 16200, 28789];
 const DEFAULT_TOKEN_FILE_PATHS = [
     "/run/openclaw/gateway-token",
     "/var/run/openclaw/gateway-token",
@@ -346,6 +346,9 @@ function discoverFromConfigDir(root) {
 }
 function parseJsonConfig(raw) {
     const obj = JSON.parse(raw);
+    const qclaw = pickQclawGatewayValues(obj);
+    if (qclaw)
+        return qclaw;
     // Prefer OpenClaw's native shape: `gateway.port` + `gateway.auth.token`.
     // The legacy `acp.url` shape is also supported for explicit user-authored configs.
     const native = pickOpenclawGatewayValues(obj?.gateway);
@@ -354,6 +357,34 @@ function parseJsonConfig(raw) {
     const acp = obj?.acp ?? obj?.gateway?.acp ?? obj?.gateway ?? obj;
     return pickConfigValues(acp);
 }
+function pickQclawGatewayValues(obj) {
+    if (!obj || typeof obj !== "object")
+        return null;
+    const port = typeof obj.port === "number" ? obj.port : undefined;
+    const configPath = typeof obj.configPath === "string" && obj.configPath.trim()
+        ? obj.configPath.trim()
+        : undefined;
+    if (!port && !configPath)
+        return null;
+    const fromConfig = configPath ? readGatewayValuesFromConfigPath(configPath) : null;
+    if (fromConfig)
+        return fromConfig;
+    if (!port)
+        return null;
+    return { url: `ws://127.0.0.1:${port}` };
+}
+function readGatewayValuesFromConfigPath(configPath) {
+    try {
+        const raw = readFileSync(expandHome(configPath), "utf8");
+        const parsed = parseJsonConfig(raw);
+        if (parsed?.url)
+            return parsed;
+    }
+    catch {
+        // qclaw.json may be copied without its referenced openclaw.json.
+    }
+    return null;
+}
 function pickOpenclawGatewayValues(gw) {
     if (!gw || typeof gw !== "object")
         return null;

package/dist/provision.js

@@ -1075,10 +1075,10 @@ function localOpenclawAcpDisabled(rawUrl) {
     if (!isLoopbackUrl(rawUrl))
         return false;
     try {
-        const file = path.join(homedir(), ".openclaw", "openclaw.json");
-        if (!existsSync(file))
+        const source = pickLocalOpenclawConfig(rawUrl);
+        if (!source)
             return false;
-        const cfg = JSON.parse(readFileSync(file, "utf8"));
+        const cfg = JSON.parse(readFileSync(source.file, "utf8"));
         return cfg?.acp?.enabled === false;
     }
     catch {
@@ -1491,12 +1491,13 @@ export async function probeOpenclawAgents(profile, opts = {}) {
         token: prepared.resolvedToken,
         timeoutMs: opts.timeoutMs ?? 3000,
     });
-    // For loopback gateways the agent roster lives in `~/.openclaw/openclaw.json`
+    // For loopback gateways the agent roster lives in local OpenClaw config
+    // (`~/.openclaw/openclaw.json`, or QClaw's `~/.qclaw/openclaw.json`)
     // and is the source of truth — listing it over the wire would require a
     // paired device identity (operator.read scope). When the WS probe is the
     // default (i.e. no test injection) we enrich the result from disk.
     if (result.ok && !result.agents && !opts.probe && isLoopbackUrl(profile.url)) {
-        const local = readLocalOpenclawAgents();
+        const local = readLocalOpenclawAgents(profile.url);
         if (local && local.length > 0)
             result.agents = local;
     }
@@ -1511,17 +1512,18 @@ function isLoopbackUrl(raw) {
         return false;
     }
 }
-function readLocalOpenclawAgents() {
+function readLocalOpenclawAgents(rawUrl) {
     try {
-        const file = path.join(homedir(), ".openclaw", "openclaw.json");
-        if (!existsSync(file))
-            return readLocalOpenclawAgentDirs() ?? [{ id: "default" }];
+        const source = pickLocalOpenclawConfig(rawUrl);
+        if (!source)
+            return readLocalOpenclawAgentDirs(path.join(homedir(), ".openclaw")) ?? [{ id: "default" }];
+        const { file, stateDir } = source;
         const cfg = JSON.parse(readFileSync(file, "utf8"));
         const list = Array.isArray(cfg?.agents?.list) ? cfg.agents.list : [];
         const explicitDefaultId = typeof cfg?.agents?.defaults?.id === "string" && cfg.agents.defaults.id
             ? cfg.agents.defaults.id
             : null;
-        const dirAgents = readLocalOpenclawAgentDirs();
+        const dirAgents = readLocalOpenclawAgentDirs(stateDir);
         const defaultId = explicitDefaultId ?? (list.length === 0 && !dirAgents ? "default" : null);
         const seen = new Set();
         const out = [];
@@ -1565,16 +1567,52 @@ function readLocalOpenclawAgents() {
         return null;
     }
 }
-function readLocalOpenclawAgentDirs() {
+function pickLocalOpenclawConfig(rawUrl) {
+    const candidates = [
+        { file: path.join(homedir(), ".openclaw", "openclaw.json"), stateDir: path.join(homedir(), ".openclaw") },
+        { file: path.join(homedir(), ".qclaw", "openclaw.json"), stateDir: path.join(homedir(), ".qclaw") },
+    ];
+    const targetPort = urlPort(rawUrl);
+    let firstExisting = null;
+    for (const candidate of candidates) {
+        if (!existsSync(candidate.file))
+            continue;
+        firstExisting ??= candidate;
+        if (!targetPort)
+            continue;
+        try {
+            const cfg = JSON.parse(readFileSync(candidate.file, "utf8"));
+            if (Number(cfg?.gateway?.port) === targetPort)
+                return candidate;
+        }
+        catch {
+            // Try the next local config.
+        }
+    }
+    return firstExisting;
+}
+function urlPort(rawUrl) {
+    if (!rawUrl)
+        return null;
     try {
-        const dir = path.join(homedir(), ".openclaw", "agents");
+        const u = new URL(rawUrl);
+        const port = Number(u.port || (u.protocol === "wss:" ? 443 : 80));
+        return Number.isInteger(port) && port > 0 ? port : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readLocalOpenclawAgentDirs(stateDir) {
+    try {
+        const dir = path.join(stateDir, "agents");
         if (!existsSync(dir))
             return null;
         const agents = readdirSync(dir, { withFileTypes: true })
             .filter((entry) => entry.isDirectory() && entry.name.length > 0)
             .map((entry) => ({
             id: entry.name,
-            workspace: path.join(dir, entry.name),
+            workspace: resolveAgentDirWorkspace(dir, entry.name),
         }));
         if (agents.length === 0)
             return null;
@@ -1591,6 +1629,10 @@ function readLocalOpenclawAgentDirs() {
         return null;
     }
 }
+function resolveAgentDirWorkspace(agentsDir, agentId) {
+    const nested = path.join(agentsDir, agentId, "agent");
+    return existsSync(nested) ? nested : path.join(agentsDir, agentId);
+}
 function resolveOpenclawIdentityName(agentId, workspace, cfg) {
     const root = workspace ?? resolveOpenclawWorkspace(agentId, cfg);
     if (!root)

package/dist/start-auth.js

@@ -1,7 +1,7 @@
 export function resolveStartAuthAction(opts) {
-    if (opts.existing && !opts.relogin)
-        return "reuse-existing";
     if (opts.installToken)
         return "install-token";
+    if (opts.existing && !opts.relogin)
+        return "reuse-existing";
     return "device-code";
 }

package/dist/turn-text.js

@@ -40,6 +40,13 @@ function replyDeliveryHint(msg) {
         ? THIRD_PARTY_REPLY_HINT
         : NON_OWNER_REPLY_HINT;
 }
+function appendConversationFields(fields, msg) {
+    const conversationId = sanitizeSenderName(msg.conversation.id);
+    fields.push(`conversation_id: ${conversationId}`);
+    if (isThirdPartyConversation(msg.conversation.id)) {
+        fields.push(`channel: ${sanitizeSenderName(msg.channel)}`);
+    }
+}
 /**
  * Read the `raw.batch` array emitted by the BotCord channel when inbox
  * drain groups multiple messages for the same `(room, topic)`. Returns the
@@ -138,6 +145,7 @@ export function composeBotCordUserTurn(msg) {
         `from: ${sanitizedSenderLabel}`,
         `to: ${msg.accountId}`,
     ];
+    appendConversationFields(headerFields, msg);
     if (isGroup && roomTitle) {
         const safeRoom = sanitizeSenderName(roomTitle.replace(/[\r\n]+/g, " "));
         headerFields.push(`room: ${safeRoom}`);
@@ -190,6 +198,7 @@ function composeBatchedTurn(msg, batch) {
         `[BotCord Messages (${batch.length} new)]`,
         `to: ${msg.accountId}`,
     ];
+    appendConversationFields(header, msg);
     if (isGroup && roomTitle) {
         const safeRoom = sanitizeSenderName(roomTitle.replace(/[\r\n]+/g, " "));
         header.push(`room: ${safeRoom}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.51",
+  "version": "0.2.53",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {