@botcord/daemon 0.2.48 → 0.2.50

package/src/gateway/runtimes/kimi.ts

@@ -0,0 +1,245 @@
+import { randomUUID } from "node:crypto";
+import { buildCliEnv } from "../cli-resolver.js";
+import { NdjsonStreamAdapter, type NdjsonEventCtx } from "./ndjson-stream.js";
+import {
+  readCommandVersion,
+  resolveCommandOnPath,
+  type ProbeDeps,
+} from "./probe.js";
+import type { RuntimeProbeResult, RuntimeRunOptions, StreamBlock } from "../types.js";
+
+function isValidKimiSessionId(sessionId: string): boolean {
+  if (sessionId.length === 0 || sessionId.length > 512) return false;
+  if (sessionId.startsWith("-")) return false;
+  for (const ch of sessionId) {
+    const code = ch.codePointAt(0);
+    if (code === undefined || code < 0x20 || code === 0x7f) return false;
+  }
+  return true;
+}
+
+function invalidKimiSessionIdError(): string {
+  return "kimi-cli: invalid sessionId (expected non-control text not starting with '-')";
+}
+
+/** Resolve the Kimi CLI executable on PATH. */
+export function resolveKimiCommand(deps: ProbeDeps = {}): string | null {
+  return resolveCommandOnPath("kimi", deps);
+}
+
+/** Probe whether the Kimi CLI is installed and report its version. */
+export function probeKimi(deps: ProbeDeps = {}): RuntimeProbeResult {
+  const command = resolveKimiCommand(deps);
+  if (!command) return { available: false };
+  return {
+    available: true,
+    path: command,
+    version: readCommandVersion(command, [], deps) ?? undefined,
+  };
+}
+
+/**
+ * Kimi CLI adapter — spawns:
+ *
+ *   kimi --work-dir <cwd> --print --output-format stream-json --session <sid> --prompt <text>
+ *
+ * `--session <sid>` resumes an existing session or creates a new session with
+ * that id, so the adapter generates a UUID on first turn and persists it for
+ * later turns. Kimi does not expose a Codex-style per-invocation AGENTS.md
+ * carrier, so dynamic `systemContext` is sent as a system-reminder prefix on
+ * the user prompt.
+ */
+export class KimiAdapter extends NdjsonStreamAdapter {
+  readonly id = "kimi-cli" as const;
+
+  private readonly explicitBinary: string | undefined;
+  private resolvedBinary: string | null = null;
+
+  constructor(opts?: { binary?: string }) {
+    super();
+    this.explicitBinary = opts?.binary ?? process.env.BOTCORD_KIMI_CLI_BIN;
+  }
+
+  probe(): RuntimeProbeResult {
+    return probeKimi();
+  }
+
+  override async run(opts: RuntimeRunOptions) {
+    if (opts.sessionId && !isValidKimiSessionId(opts.sessionId)) {
+      return { text: "", newSessionId: "", error: invalidKimiSessionIdError() };
+    }
+    const sessionId = opts.sessionId || randomUUID();
+    return super.run({ ...opts, sessionId });
+  }
+
+  protected resolveBinary(): string {
+    if (this.explicitBinary) return this.explicitBinary;
+    if (this.resolvedBinary) return this.resolvedBinary;
+    this.resolvedBinary = resolveKimiCommand() ?? "kimi";
+    return this.resolvedBinary;
+  }
+
+  protected buildArgs(opts: RuntimeRunOptions): string[] {
+    const sessionId = opts.sessionId || randomUUID();
+    if (!isValidKimiSessionId(sessionId)) throw new Error(invalidKimiSessionIdError());
+
+    const args = [
+      "--work-dir",
+      opts.cwd,
+      "--print",
+      "--output-format",
+      "stream-json",
+      "--session",
+      sessionId,
+      "--afk",
+    ];
+    if (opts.extraArgs?.length) args.push(...opts.extraArgs);
+    args.push("--prompt", promptWithSystemContext(opts.text, opts.systemContext));
+    return args;
+  }
+
+  protected spawnEnv(opts: RuntimeRunOptions): NodeJS.ProcessEnv {
+    const cliEnv = buildCliEnv({
+      hubUrl: opts.hubUrl,
+      accountId: opts.accountId,
+      basePath: process.env.PATH,
+    });
+    return {
+      ...process.env,
+      ...cliEnv,
+      FORCE_COLOR: "0",
+      NO_COLOR: "1",
+    };
+  }
+
+  protected handleEvent(raw: unknown, ctx: NdjsonEventCtx): void {
+    const obj = raw as KimiStreamJsonEvent;
+
+    const status = kimiStatusEvent(obj);
+    if (status) ctx.emitStatus(status);
+
+    ctx.emitBlock(normalizeBlock(obj, ctx.seq));
+
+    const sessionId = kimiSessionId(obj);
+    if (sessionId) ctx.state.newSessionId = sessionId;
+
+    if (obj.role === "assistant") {
+      const text = extractText(obj.content);
+      if (text) {
+        ctx.appendAssistantText(text);
+        ctx.state.finalText = text;
+      }
+      return;
+    }
+
+    const err = kimiErrorText(obj);
+    if (err) ctx.state.errorText = err;
+  }
+}
+
+type KimiContentPart = {
+  type?: string;
+  text?: string;
+  think?: string;
+};
+
+type KimiToolCall = {
+  id?: string;
+  function?: { name?: string; arguments?: string | null };
+};
+
+type KimiStreamJsonEvent = {
+  role?: string;
+  content?: string | KimiContentPart[] | null;
+  tool_calls?: KimiToolCall[] | null;
+  tool_call_id?: string | null;
+  content_type?: string;
+  file_path?: string;
+  session_id?: string;
+  id?: string;
+  category?: string;
+  type?: string;
+  title?: string;
+  body?: string;
+  severity?: string;
+  error?: string | { message?: string };
+  message?: string;
+};
+
+function promptWithSystemContext(text: string, systemContext: string | undefined): string {
+  if (!systemContext) return text;
+  return `<system-reminder>\n${systemContext}\n</system-reminder>\n\n${text}`;
+}
+
+function extractText(content: KimiStreamJsonEvent["content"]): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((part) => part?.type === "text" && typeof part.text === "string")
+    .map((part) => part.text)
+    .join("");
+}
+
+function hasThinking(content: KimiStreamJsonEvent["content"]): boolean {
+  return Array.isArray(content)
+    ? content.some((part) => part?.type === "think" && typeof part.think === "string" && part.think)
+    : false;
+}
+
+function firstToolName(toolCalls: KimiToolCall[] | null | undefined): string {
+  const name = toolCalls?.find((t) => typeof t.function?.name === "string")?.function?.name;
+  return name || "tool";
+}
+
+function kimiSessionId(obj: KimiStreamJsonEvent): string | undefined {
+  return typeof obj.session_id === "string" && obj.session_id ? obj.session_id : undefined;
+}
+
+function kimiErrorText(obj: KimiStreamJsonEvent): string | undefined {
+  if (typeof obj.error === "string" && obj.error) return obj.error;
+  if (obj.error && typeof obj.error === "object") {
+    const message = obj.error.message;
+    if (typeof message === "string" && message) return message;
+  }
+  if (obj.type === "error" && typeof obj.message === "string" && obj.message) {
+    return obj.message;
+  }
+  if (obj.severity === "error") {
+    return [obj.title, obj.body].filter(Boolean).join(": ") || "kimi-cli error";
+  }
+  return undefined;
+}
+
+function kimiStatusEvent(
+  obj: KimiStreamJsonEvent,
+): import("../types.js").RuntimeStatusEvent | undefined {
+  if (obj.role === "assistant" && hasThinking(obj.content)) {
+    return { kind: "thinking", phase: "started", label: "Thinking" };
+  }
+  if (obj.role === "assistant" && obj.tool_calls?.length) {
+    return { kind: "thinking", phase: "updated", label: firstToolName(obj.tool_calls) };
+  }
+  if (obj.role === "assistant" && extractText(obj.content)) {
+    return { kind: "thinking", phase: "stopped" };
+  }
+  if (obj.role === "tool") {
+    return { kind: "thinking", phase: "updated", label: "Tool result" };
+  }
+  return undefined;
+}
+
+function normalizeBlock(obj: KimiStreamJsonEvent, seq: number): StreamBlock {
+  let kind: StreamBlock["kind"] = "other";
+  if (obj.role === "assistant") {
+    if (obj.tool_calls?.length) kind = "tool_use";
+    else if (extractText(obj.content)) kind = "assistant_text";
+    else if (hasThinking(obj.content)) kind = "other";
+  } else if (obj.role === "tool") {
+    kind = "tool_result";
+  } else if (obj.file_path && typeof obj.content === "string") {
+    kind = "other";
+  } else if (obj.category || obj.severity) {
+    kind = "system";
+  }
+  return { raw: obj, kind, seq };
+}

package/src/gateway/runtimes/registry.ts

@@ -1,7 +1,9 @@
 import { ClaudeCodeAdapter, probeClaude } from "./claude-code.js";
 import { CodexAdapter, probeCodex } from "./codex.js";
+import { DeepseekTuiAdapter, probeDeepseekTui } from "./deepseek-tui.js";
 import { GeminiAdapter, probeGemini } from "./gemini.js";
 import { HermesAgentAdapter, probeHermesAgent } from "./hermes-agent.js";
+import { KimiAdapter, probeKimi } from "./kimi.js";
 import { OpenclawAcpAdapter, probeOpenclaw } from "./openclaw-acp.js";
 import type { RuntimeAdapter, RuntimeProbeResult } from "../types.js";
 
@@ -55,6 +57,28 @@ export const codexModule: RuntimeModule = {
   create: () => new CodexAdapter(),
 };
 
+/** Built-in runtime module entry for DeepSeek TUI. */
+export const deepseekTuiModule: RuntimeModule = {
+  id: "deepseek-tui",
+  displayName: "DeepSeek TUI",
+  binary: "deepseek",
+  envVar: "BOTCORD_DEEPSEEK_TUI_BIN",
+  probe: () => probeDeepseekTui(),
+  create: () => new DeepseekTuiAdapter(),
+  installHint:
+    "Install DeepSeek TUI and ensure the `deepseek` dispatcher is on PATH, or set BOTCORD_DEEPSEEK_TUI_BIN.",
+};
+
+/** Built-in runtime module entry for Kimi CLI. */
+export const kimiModule: RuntimeModule = {
+  id: "kimi-cli",
+  displayName: "Kimi CLI",
+  binary: "kimi",
+  envVar: "BOTCORD_KIMI_CLI_BIN",
+  probe: () => probeKimi(),
+  create: () => new KimiAdapter(),
+};
+
 /** Built-in runtime module entry for Hermes Agent (ACP stdio). */
 export const hermesAgentModule: RuntimeModule = {
   id: "hermes-agent",
@@ -96,6 +120,8 @@ export const openclawAcpModule: RuntimeModule = {
 export const RUNTIME_MODULES: readonly RuntimeModule[] = [
   claudeCodeModule,
   codexModule,
+  deepseekTuiModule,
+  kimiModule,
   hermesAgentModule,
   geminiModule,
   openclawAcpModule,

package/src/mention-scan.ts

@@ -24,8 +24,12 @@ export interface MentionTargets {
 export function scanMention(text: string | undefined, targets: MentionTargets): boolean {
   if (!text) return false;
   const lower = text.toLowerCase();
+  const normalizedAgentId = targets.agentId?.trim().toLowerCase();
+  if (normalizedAgentId && lower.includes("(" + normalizedAgentId + ")")) {
+    return true;
+  }
   const candidates: string[] = [];
-  if (targets.agentId) candidates.push(targets.agentId.toLowerCase());
+  if (normalizedAgentId) candidates.push(normalizedAgentId);
   if (targets.displayName) {
     const trimmed = targets.displayName.trim();
     if (trimmed) candidates.push(trimmed.toLowerCase());

package/src/skill-index.ts

@@ -0,0 +1,232 @@
+import {
+  existsSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import {
+  agentCodexHomeDir,
+  agentWorkspaceDir,
+} from "./agent-workspace.js";
+
+const MAX_SKILLS = 24;
+const MAX_DESCRIPTION_CHARS = 260;
+const MAX_SKILL_MD_READ_CHARS = 8192;
+
+export interface SoftSkillEntry {
+  name: string;
+  path: string;
+  source: string;
+  description?: string;
+  mtimeMs: number;
+}
+
+export interface SkillIndexOptions {
+  extraDirs?: string[];
+  includeGlobal?: boolean;
+}
+
+export function defaultSkillDirs(
+  agentId: string,
+  opts: SkillIndexOptions = {},
+): Array<{ dir: string; source: string }> {
+  const includeGlobal = opts.includeGlobal !== false;
+  const dirs: Array<{ dir: string; source: string }> = [
+    {
+      dir: path.join(agentWorkspaceDir(agentId), ".claude", "skills"),
+      source: "agent-claude",
+    },
+    {
+      dir: path.join(agentCodexHomeDir(agentId), "skills"),
+      source: "agent-codex",
+    },
+  ];
+
+  if (includeGlobal) {
+    dirs.push(
+      { dir: path.join(homedir(), ".claude", "skills"), source: "global-claude" },
+      { dir: path.join(homedir(), ".codex", "skills"), source: "global-codex" },
+    );
+  }
+
+  const envDirs = parseSkillDirsEnv(process.env.BOTCORD_SKILL_DIRS);
+  for (const dir of [...envDirs, ...(opts.extraDirs ?? [])]) {
+    dirs.push({ dir, source: "external" });
+  }
+
+  return dedupeDirs(dirs);
+}
+
+export function scanSoftSkills(
+  agentId: string,
+  opts: SkillIndexOptions = {},
+): SoftSkillEntry[] {
+  const byName = new Map<string, SoftSkillEntry>();
+  const byPath = new Set<string>();
+
+  for (const root of defaultSkillDirs(agentId, opts)) {
+    if (!existsSync(root.dir)) continue;
+    let children: string[];
+    try {
+      children = readdirSync(root.dir);
+    } catch {
+      continue;
+    }
+
+    for (const child of children) {
+      const skillDir = path.join(root.dir, child);
+      const skillMd = path.join(skillDir, "SKILL.md");
+      if (byPath.has(skillMd) || !existsSync(skillMd)) continue;
+      byPath.add(skillMd);
+
+      let st;
+      try {
+        st = statSync(skillMd);
+        if (!st.isFile()) continue;
+      } catch {
+        continue;
+      }
+
+      const parsed = parseSkillFile(skillMd, child);
+      const existing = byName.get(parsed.name);
+      const entry: SoftSkillEntry = {
+        name: parsed.name,
+        path: skillMd,
+        source: root.source,
+        description: parsed.description,
+        mtimeMs: st.mtimeMs,
+      };
+      if (!existing || priority(root.source) < priority(existing.source)) {
+        byName.set(entry.name, entry);
+      }
+    }
+  }
+
+  return Array.from(byName.values())
+    .sort((a, b) => a.name.localeCompare(b.name))
+    .slice(0, MAX_SKILLS);
+}
+
+export function buildSoftSkillIndexPrompt(
+  agentId: string,
+  opts: SkillIndexOptions = {},
+): string | null {
+  const skills = scanSoftSkills(agentId, opts);
+  if (skills.length === 0) return null;
+
+  const lines = [
+    "[BotCord Daemon Skill Index]",
+    "The daemon scanned these SKILL.md files on disk this turn. This is a soft skill index for runtimes whose native skill registry may not hot-reload during resumed sessions.",
+    "If the user's request matches a listed skill and the native skill is not already active, read that SKILL.md file directly and follow its workflow manually. Do not assume this index creates new native tools; use only tools and CLIs that are actually available.",
+    "",
+  ];
+
+  for (const skill of skills) {
+    const desc = skill.description ? ` - ${skill.description}` : "";
+    lines.push(`- ${skill.name} (${skill.source}): ${skill.path}${desc}`);
+  }
+
+  return lines.join("\n");
+}
+
+function parseSkillFile(
+  skillMd: string,
+  fallbackName: string,
+): { name: string; description?: string } {
+  let raw = "";
+  try {
+    raw = readFileSync(skillMd, "utf8").slice(0, MAX_SKILL_MD_READ_CHARS);
+  } catch {
+    return { name: fallbackName };
+  }
+
+  const fm = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  const frontmatter = fm?.[1] ?? "";
+  const name = readYamlScalar(frontmatter, "name") ?? fallbackName;
+  const description =
+    readYamlScalar(frontmatter, "description") ??
+    readMarkdownDescription(raw) ??
+    undefined;
+
+  return {
+    name: sanitizeInline(name) || fallbackName,
+    description: description ? truncate(sanitizeInline(description), MAX_DESCRIPTION_CHARS) : undefined,
+  };
+}
+
+function readYamlScalar(frontmatter: string, key: string): string | null {
+  const re = new RegExp(`^${key}:\\s*(.+?)\\s*$`, "m");
+  const match = frontmatter.match(re);
+  if (!match) return null;
+  return unquote(match[1] ?? "");
+}
+
+function readMarkdownDescription(raw: string): string | null {
+  const purpose = raw.match(/\*\*Purpose:\*\*\s*([^\n]+)/i);
+  if (purpose?.[1]) return purpose[1];
+  const firstParagraph = raw
+    .replace(/^---\r?\n[\s\S]*?\r?\n---/, "")
+    .split(/\n\s*\n/)
+    .map((s) => s.trim())
+    .find((s) => s && !s.startsWith("#"));
+  return firstParagraph ?? null;
+}
+
+function parseSkillDirsEnv(value: string | undefined): string[] {
+  if (!value) return [];
+  return value
+    .split(path.delimiter)
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+function dedupeDirs(
+  dirs: Array<{ dir: string; source: string }>,
+): Array<{ dir: string; source: string }> {
+  const seen = new Set<string>();
+  const out: Array<{ dir: string; source: string }> = [];
+  for (const entry of dirs) {
+    const resolved = path.resolve(entry.dir);
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+    out.push({ dir: resolved, source: entry.source });
+  }
+  return out;
+}
+
+function priority(source: string): number {
+  switch (source) {
+    case "agent-claude":
+      return 0;
+    case "agent-codex":
+      return 1;
+    case "global-claude":
+      return 2;
+    case "global-codex":
+      return 3;
+    default:
+      return 4;
+  }
+}
+
+function unquote(value: string): string {
+  const trimmed = value.trim();
+  if (
+    (trimmed.startsWith("\"") && trimmed.endsWith("\"")) ||
+    (trimmed.startsWith("'") && trimmed.endsWith("'"))
+  ) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+
+function sanitizeInline(value: string): string {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+function truncate(value: string, max: number): string {
+  if (value.length <= max) return value;
+  return `${value.slice(0, Math.max(0, max - 3))}...`;
+}

package/src/system-context.ts

@@ -11,6 +11,7 @@
  *   3. `[BotCord Working Memory]`
  *   4. `[BotCord Room Context]` (group rooms, via optional async fetcher)
  *   5. `[BotCord Cross-Room Awareness]` (optional activity tracker)
+ *   6. `[BotCord Daemon Skill Index]` (soft skill hot-reload index)
  *
  * Behavior:
  *   - Working memory is loaded fresh per turn, so a `memory set` from another
@@ -30,6 +31,7 @@ import { buildWorkingMemoryPrompt, readWorkingMemory } from "./working-memory.js
 import { readIdentity } from "./agent-workspace.js";
 import { classifyActivitySender } from "./sender-classify.js";
 import { log } from "./log.js";
+import { buildSoftSkillIndexPrompt } from "./skill-index.js";
 
 /**
  * Async per-turn room-context builder (see `room-context.ts`). Returns the
@@ -77,6 +79,11 @@ export interface SystemContextDeps {
    * + cheap — consulted every turn even when roomContextBuilder is absent.
    */
   loopRiskBuilder?: (message: GatewayInboundMessage) => string | null;
+  /**
+   * Optional soft skill index builder. Defaults to scanning daemon-known skill
+   * dirs each turn. Return null to suppress the block.
+   */
+  skillIndexBuilder?: (message: GatewayInboundMessage) => string | null;
 }
 
 function safeReadWorkingMemory(agentId: string) {
@@ -172,14 +179,29 @@ export function createDaemonSystemContextBuilder(
     }
   };
 
+  const buildSkillIndex = (message: GatewayInboundMessage): string | null => {
+    try {
+      if (deps.skillIndexBuilder) return deps.skillIndexBuilder(message);
+      return buildSoftSkillIndexPrompt(deps.agentId);
+    } catch (err) {
+      log.warn("system-context: skill index build failed — skipping skill block", {
+        agentId: deps.agentId,
+        roomId: message.conversation.id,
+        err: err instanceof Error ? err.message : String(err),
+      });
+      return null;
+    }
+  };
+
   if (!deps.roomContextBuilder) {
     const syncBuilder = (message: GatewayInboundMessage): string | undefined => {
       const { identity, ownerScene, memory, digest } = gatherSyncBlocks(message);
       // Loop-risk sits at the end so its "reply NO_REPLY unless…" guidance
       // is the last thing the model sees before the user turn body.
       // Identity sits at the very front so it frames every other block.
+      const skillIndex = buildSkillIndex(message);
       const loopRisk = runLoopRisk(message);
-      return assemble([identity, ownerScene, memory, digest, loopRisk]);
+      return assemble([identity, ownerScene, memory, digest, skillIndex, loopRisk]);
     };
     // Compile-time witness that the narrower sync signature still satisfies
     // `SystemContextBuilder` (which allows async). Prevents the two contracts
@@ -209,8 +231,9 @@ export function createDaemonSystemContextBuilder(
         err: err instanceof Error ? err.message : String(err),
       });
     }
+    const skillIndex = buildSkillIndex(message);
     const loopRisk = runLoopRisk(message);
-    return assemble([identity, ownerScene, memory, roomBlock, digest, loopRisk]);
+    return assemble([identity, ownerScene, memory, roomBlock, digest, skillIndex, loopRisk]);
   };
   const _typecheck: SystemContextBuilder = asyncBuilder;
   void _typecheck;

package/src/turn-text.ts

@@ -88,6 +88,16 @@ interface BatchedEntry {
   mentioned?: unknown;
 }
 
+interface RoomContextRaw {
+  room_id?: unknown;
+  room_name?: unknown;
+  room_rule?: unknown;
+  room_member_count?: unknown;
+  room_member_names?: unknown;
+  my_role?: unknown;
+  my_can_send?: unknown;
+}
+
 /**
  * Read the `raw.batch` array emitted by the BotCord channel when inbox
  * drain groups multiple messages for the same `(room, topic)`. Returns the
@@ -125,6 +135,36 @@ function entryText(e: BatchedEntry): string {
   return "";
 }
 
+function formatRoomContext(raw: unknown, fallback: { id: string; title?: string }): string[] {
+  const r = raw && typeof raw === "object" ? (raw as RoomContextRaw) : {};
+  const roomId = typeof r.room_id === "string" && r.room_id ? r.room_id : fallback.id;
+  const roomName = typeof r.room_name === "string" && r.room_name ? r.room_name : fallback.title;
+  const memberCount =
+    typeof r.room_member_count === "number" && Number.isFinite(r.room_member_count)
+      ? r.room_member_count
+      : undefined;
+  const memberNames = Array.isArray(r.room_member_names)
+    ? r.room_member_names.filter((n): n is string => typeof n === "string" && n.length > 0)
+    : [];
+  const role = typeof r.my_role === "string" && r.my_role ? r.my_role : undefined;
+  const canSend = typeof r.my_can_send === "boolean" ? r.my_can_send : undefined;
+
+  const parts = [`id: ${sanitizeSenderName(roomId)}`];
+  if (roomName) parts.push(`name: ${sanitizeSenderName(roomName)}`);
+  if (memberCount !== undefined) {
+    const names = memberNames.slice(0, 10).map(sanitizeSenderName).join(", ");
+    parts.push(names ? `members: ${memberCount}: ${names}` : `members: ${memberCount}`);
+  }
+  if (role) parts.push(`role: ${sanitizeSenderName(role)}`);
+  if (canSend !== undefined) parts.push(`can_send: ${canSend ? "true" : "false"}`);
+
+  const lines = [`[BotCord Room] | ${parts.join(" | ")}`];
+  if (typeof r.room_rule === "string" && r.room_rule.trim()) {
+    lines.push(`[Room Rule] ${sanitizeUntrustedContent(r.room_rule.trim())}`);
+  }
+  return lines;
+}
+
 /**
  * Compose the user-turn text for a BotCord inbound message.
  *
@@ -193,6 +233,7 @@ export function composeBotCordUserTurn(msg: GatewayInboundMessage): string {
 
   const lines: string[] = [
     headerFields.join(" | "),
+    ...(isGroup ? formatRoomContext(msg.raw, { id: conversation.id, title: roomTitle }) : []),
     `<${tag} sender="${sanitizedSenderLabel}" sender_kind="${senderKindAttr}">`,
     trimmed,
     `</${tag}>`,
@@ -256,6 +297,7 @@ function composeBatchedTurn(
   const hint = isGroup ? GROUP_HINT : DIRECT_HINT;
   const lines: string[] = [
     header.join(" | "),
+    ...(isGroup ? formatRoomContext(msg.raw, { id: conversation.id, title: roomTitle }) : []),
     blocks.join("\n"),
     "",
     hint,