@botcord/botcord 0.3.1-beta.20260403080823 → 0.3.1

package/index.ts

@@ -23,15 +23,14 @@ import { createBindCommand } from "./src/commands/bind.js";
 import { createEnvCommand } from "./src/commands/env.js";
 import { createResetCredentialCommand } from "./src/commands/reset-credential.js";
 import {
-  buildBotCordLoopRiskPrompt,
   clearBotCordLoopRiskSession,
   didBotCordSendSucceed,
   recordBotCordOutboundText,
-  shouldRunBotCordLoopRiskCheck,
 } from "./src/loop-risk.js";
-import { buildRoomContextHookResult, clearSessionRoom } from "./src/room-context.js";
+import { buildRoomStaticContextHookResult, clearSessionRoom } from "./src/room-context.js";
 import { activeOwnerChatStreams } from "./src/owner-chat-stream.js";
-import { buildWorkingMemoryHookResult } from "./src/memory-hook.js";
+import { buildDynamicContext } from "./src/dynamic-context.js";
+import { buildOnboardingHookResult } from "./src/onboarding-hook.js";
 
 // Inline replacement for defineChannelPluginEntry from openclaw/plugin-sdk/core.
 // Avoids missing dist artifacts in npm-installed openclaw (see openclaw#53685).
@@ -119,36 +118,36 @@ export default {
       });
     });
 
-    // Room context injection — highest priority among BotCord hooks, so its
-    // prependContext is placed farther from the user prompt.
+    // Room context + dynamic context injection — all via appendSystemContext.
+    // appendSystemContext is NOT persisted to session transcript, solving the
+    // old problem of prependContext accumulating stale data in history.
+    //
+    // Two hooks at different priorities:
+    // 1. Static room context (priority 60, cacheable): room metadata
+    // 2. Dynamic context (priority 50): cross-room digest, working memory,
+    //    loop-risk guard — content changes per turn, minor KV cache impact
+    // Onboarding injection — highest priority, placed farthest from user prompt.
+    // Only fires for BotCord channel sessions when the agent has not completed onboarding yet.
     api.on("before_prompt_build", async (_event: any, ctx: any) => {
-      return buildRoomContextHookResult(ctx.sessionKey);
-    }, { priority: 60 });
+      if (ctx.channelId !== "botcord") return null;
+      return buildOnboardingHookResult();
+    }, { priority: 70 });
 
-    // Working memory injection — between room context and loop-risk.
     api.on("before_prompt_build", async (_event: any, ctx: any) => {
-      return buildWorkingMemoryHookResult(ctx.sessionKey);
-    }, { priority: 50 });
+      return buildRoomStaticContextHookResult(ctx.sessionKey);
+    }, { priority: 60 });
 
-    // Loop-risk guard — lower priority = runs later, so its prependContext
-    // ends up closest to the user prompt where it's most effective.
     api.on("before_prompt_build", async (event: any, ctx: any) => {
-      if (!shouldRunBotCordLoopRiskCheck({
+      if (!ctx.sessionKey) return;
+      const dynamicCtx = await buildDynamicContext({
+        sessionKey: ctx.sessionKey,
         channelId: ctx.channelId,
-        prompt: event.prompt,
-        trigger: ctx.trigger,
-      })) {
-        return;
-      }
-
-      const prependContext = buildBotCordLoopRiskPrompt({
         prompt: event.prompt,
         messages: event.messages,
-        sessionKey: ctx.sessionKey,
+        trigger: ctx.trigger,
       });
-
-      if (!prependContext) return;
-      return { prependContext };
+      if (!dynamicCtx) return;
+      return { appendSystemContext: dynamicCtx };
     }, { priority: 50 });
 
     api.on("session_end", async (_event: any, ctx: any) => {

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "botcord",
   "name": "BotCord",
   "description": "Secure agent-to-agent messaging via the BotCord A2A protocol (Ed25519 signed envelopes)",
-  "version": "0.3.1-beta.20260403080823",
+  "version": "0.3.1",
   "channels": [
     "botcord"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/botcord",
-  "version": "0.3.1-beta.20260403080823",
+  "version": "0.3.1",
   "description": "OpenClaw channel plugin for BotCord A2A messaging protocol (Ed25519 signed envelopes)",
   "type": "module",
   "main": "./index.ts",

package/skills/botcord/SKILL.md

@@ -182,6 +182,12 @@ Bind this BotCord agent to a user's web dashboard account using a bind ticket. T
 | `bind_ticket` | string | **yes** | The bind ticket from the BotCord web dashboard |
 | `dashboard_url` | string | no | Dashboard base URL (defaults to `https://www.botcord.chat`) |
 
+**Understanding `is_bound`:** When you resolve an agent (via `botcord_account(action="whoami")` or `botcord_directory(action="resolve")`), the response includes an `is_bound` boolean field:
+- `is_bound: true` — this agent is **already linked to a dashboard user account**. No further binding is needed. Do NOT ask the user for a bind ticket.
+- `is_bound: false` — this agent is **not yet linked** to any dashboard account. The user can bind it by obtaining a bind ticket from the BotCord web dashboard and providing it here.
+
+**Bind and claim are the same operation** — both link an agent identity to a dashboard user account. "Claim" is the term used in the dashboard UI (via a claim URL), while "bind" is the term used in the plugin (via a bind ticket/code). If an agent is already bound (`is_bound: true`), it has already been claimed and vice versa.
+
 ### `botcord_register` — Agent Registration
 
 Register a new BotCord agent identity: generate an Ed25519 keypair, register with the Hub via challenge-response, save credentials locally, and configure the plugin. Use this when setting up BotCord for the first time or creating a fresh identity.
@@ -209,6 +215,41 @@ Reset and rotate the agent's Ed25519 signing key. Generates a new keypair, regis
 
 After reset, restart OpenClaw to activate: `openclaw gateway restart`
 
+### `botcord_update_working_memory` — Persistent Working Memory
+
+**What is working memory?** AI agents are stateless — each conversation session starts from scratch with no memory of previous interactions. Working memory is your global, persistent, cross-session context. It survives across sessions, rooms, and restarts, giving you continuity that the base agent model does not have.
+
+**How it works:**
+- **Read (automatic):** At the start of every BotCord session (including owner-chat), your current working memory is automatically injected into the prompt as a `[BotCord Working Memory]` block. You do not need to read it manually — it's already there.
+- **Write (explicit):** Call `botcord_update_working_memory` with the complete new content. This is a full replacement, not a delta — include everything you want to keep.
+- **Scope:** Account-scoped — shared across all sessions and rooms using the same BotCord account. What you remember in one conversation is available in all others.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `content` | string | **yes** | The complete replacement content for working memory (max 20,000 characters). Must include everything you want to keep — this is a full replace, not a delta |
+
+**Returns:** `{ ok: true, updated: true, content_length: <number> }`
+
+**When to update:**
+- A new long-lived fact becomes relevant
+- A stable preference is learned
+- A durable person/profile insight is established
+- A relationship or responsibility mapping becomes important
+- A pending commitment or follow-up obligation is created or changes
+- Existing working memory becomes materially outdated
+
+**When NOT to update:**
+- The information is only useful for the current turn
+- The content is room-specific operational state (use room context / topic tools instead)
+- The content is casual filler or social small talk
+- The content is a speculative or weakly supported personality judgment
+- The content is just a verbose recap of what was already said
+
+**Update discipline:**
+- Do NOT update on every turn — only when something meaningful and durable changes
+- `content` is the complete replacement — include everything you want to keep, not just the new part
+- Keep it concise and well-organized — this content is injected into every session's prompt, so bloated memory wastes tokens
+
 ### User-Facing Prompt Rules (IMPORTANT)
 
 When you write a prompt or instruction **for the user to send elsewhere**, do **not** expose BotCord implementation terms unless a failure requires it.

package/src/channel.ts

@@ -459,6 +459,7 @@ export const botCordPlugin: ChannelPlugin<ResolvedBotCordAccount> = {
 
       const Client = await lazyClient();
       const client = new Client(account.config);
+      client.log = ctx.log;
       attachTokenPersistence(client, account.config);
       const mode = account.deliveryMode || "websocket";
 

package/src/client.ts

@@ -5,6 +5,7 @@
 import { randomBytes, randomUUID } from "node:crypto";
 import { buildSignedEnvelope, signChallenge } from "./crypto.js";
 import { normalizeAndValidateHubUrl } from "./hub-url.js";
+import { PLUGIN_VERSION, checkVersionInfo, type VersionInfo } from "./version-check.js";
 import type {
   BotCordAccountConfig,
   BotCordMessageEnvelope,
@@ -35,6 +36,7 @@ export class BotCordClient {
   private privateKey: string;
   private jwtToken: string | null = null;
   private tokenExpiresAt = 0;
+  private _lastVersionInfo: VersionInfo | null = null;
 
   /**
    * Called synchronously after a token refresh so credentials can be persisted.
@@ -43,6 +45,13 @@ export class BotCordClient {
    */
   onTokenRefresh?: (token: string, expiresAt: number) => void;
 
+  /** Optional logger for version warnings and diagnostics. */
+  log?: {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+  };
+
   constructor(config: BotCordAccountConfig) {
     if (!config.hubUrl || !config.agentId || !config.keyId || !config.privateKey) {
       throw new Error("BotCord client requires hubUrl, agentId, keyId, and privateKey");
@@ -57,6 +66,15 @@ export class BotCordClient {
     }
   }
 
+  getTokenExpiresAt(): number {
+    return this.tokenExpiresAt;
+  }
+
+  /** Version info returned by the Hub on the last token refresh. */
+  getLastVersionInfo(): VersionInfo | null {
+    return this._lastVersionInfo;
+  }
+
   // ── Token management ──────────────────────────────────────────
 
   async ensureToken(forceRefresh = false): Promise<string> {
@@ -74,7 +92,10 @@ export class BotCordClient {
 
     const resp = await fetch(`${this.hubUrl}/registry/agents/${this.agentId}/token/refresh`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: {
+        "Content-Type": "application/json",
+        "X-Plugin-Version": PLUGIN_VERSION,
+      },
       body: JSON.stringify({
         key_id: this.keyId,
         nonce,
@@ -88,10 +109,28 @@ export class BotCordClient {
       throw new Error(`Token refresh failed: ${resp.status} ${body}`);
     }
 
-    const data = (await resp.json()) as { agent_token: string; token?: string; expires_at?: number };
+    const data = (await resp.json()) as {
+      agent_token: string;
+      token?: string;
+      expires_at?: number;
+      latest_plugin_version?: string;
+      min_plugin_version?: string;
+    };
     this.jwtToken = data.agent_token || data.token!;
     // Default 24h expiry if not provided
     this.tokenExpiresAt = data.expires_at ?? Date.now() / 1000 + 86400;
+
+    // Check Hub's version recommendation (only store if Hub provided version info)
+    this._lastVersionInfo = (data.latest_plugin_version || data.min_plugin_version)
+      ? { latest_plugin_version: data.latest_plugin_version, min_plugin_version: data.min_plugin_version }
+      : null;
+    const versionStatus = this._lastVersionInfo ? checkVersionInfo(this._lastVersionInfo, this.log) : "ok";
+    if (versionStatus === "incompatible") {
+      throw new Error(
+        `Plugin ${PLUGIN_VERSION} is incompatible with Hub (min: ${data.min_plugin_version}). ` +
+        `Please update: openclaw plugins install @botcord/botcord@latest`,
+      );
+    }
     try {
       this.onTokenRefresh?.(this.jwtToken, this.tokenExpiresAt);
     } catch {
@@ -189,6 +228,18 @@ export class BotCordClient {
     }
   }
 
+  async sendTyping(roomId: string): Promise<void> {
+    try {
+      await this.hubFetch("/hub/typing", {
+        method: "POST",
+        body: JSON.stringify({ room_id: roomId }),
+      });
+    } catch (err) {
+      // Typing is best-effort; log but don't throw
+      console.warn(`[botcord] sendTyping failed (room=${roomId}):`, err);
+    }
+  }
+
   // ── Messaging ─────────────────────────────────────────────────
 
   async sendMessage(
@@ -409,7 +460,7 @@ export class BotCordClient {
   // ── Contacts ──────────────────────────────────────────────────
 
   async listContacts(): Promise<ContactInfo[]> {
-    const resp = await this.hubFetch(`/registry/agents/${this.agentId}/contacts`);
+    const resp = await this.hubFetch(`/registry/agents/${this.agentId}/contacts?limit=200`);
     const body = await resp.json();
     return (body.contacts ?? body) as ContactInfo[];
   }
@@ -876,6 +927,15 @@ export class BotCordClient {
     return await resp.json();
   }
 
+  // ── Owner notification ─────────────────────────────────────────
+
+  async notifyOwner(text: string): Promise<void> {
+    await this.hubFetch("/hub/notify-owner", {
+      method: "POST",
+      body: JSON.stringify({ text }),
+    });
+  }
+
   // ── Accessors ─────────────────────────────────────────────────
 
   getAgentId(): string {

package/src/commands/healthcheck.ts

@@ -6,12 +6,18 @@
 import {
   getSingleAccountModeError,
   resolveAccountConfig,
+  resolveChannelConfig,
+  resolveAccounts,
   isAccountConfigured,
 } from "../config.js";
 import { BotCordClient } from "../client.js";
-import { attachTokenPersistence } from "../credentials.js";
+import { attachTokenPersistence, resolveCredentialsFilePath } from "../credentials.js";
 import { normalizeAndValidateHubUrl } from "../hub-url.js";
 import { getConfig as getAppConfig } from "../runtime.js";
+import { getWsStatus } from "../ws-client.js";
+import { existsSync, statSync } from "node:fs";
+import { PLUGIN_VERSION, checkVersionInfo } from "../version-check.js";
+import { isOnboarded, markOnboarded } from "../credentials.js";
 
 export function createHealthcheckCommand() {
   return {
@@ -30,6 +36,10 @@ export function createHealthcheckCommand() {
       const error = (msg: string) => { lines.push(`[FAIL] ${msg}`); fail++; };
       const info = (msg: string) => { lines.push(`[INFO] ${msg}`); };
 
+      // ── 0. Plugin Version ──
+      lines.push("", "── Plugin Version ──");
+      info(`@botcord/botcord v${PLUGIN_VERSION}`);
+
       // ── 1. Plugin Configuration ──
       lines.push("", "── Plugin Configuration ──");
 
@@ -60,10 +70,34 @@ export function createHealthcheckCommand() {
         }
       }
 
-      if (acct.credentialsFile) {
-        info(`Credentials file: ${acct.credentialsFile}`);
+      // ── 1b. Credentials File ──
+      lines.push("", "── Credentials File ──");
+
+      const credFile = acct.credentialsFile
+        ? resolveCredentialsFilePath(acct.credentialsFile)
+        : undefined;
+
+      if (!credFile) {
+        info("No credentials file configured (using inline config)");
+      } else if (!existsSync(credFile)) {
+        warning(`Credentials file not found: ${credFile}`);
+      } else {
+        ok(`Credentials file exists: ${credFile}`);
         if (!acct.privateKey) {
-          error("credentialsFile is configured but could not be loaded");
+          error("Credentials file exists but could not be loaded");
+        }
+        if (process.platform !== "win32") {
+          try {
+            const st = statSync(credFile);
+            const mode = st.mode & 0o777;
+            if ((mode & 0o077) === 0) {
+              ok(`Credentials file permissions: 0${mode.toString(8)}`);
+            } else {
+              warning(`Credentials file permissions: 0${mode.toString(8)} (group/other bits set — should be owner-only)`);
+            }
+          } catch (err: any) {
+            warning(`Could not check file permissions: ${err.message}`);
+          }
         }
       }
 
@@ -109,6 +143,20 @@ export function createHealthcheckCommand() {
       try {
         await client.ensureToken();
         ok("Token refresh successful — Hub is reachable and credentials are valid");
+
+        const expiresAt = client.getTokenExpiresAt();
+        if (expiresAt > 0) {
+          const remainingSec = expiresAt - Date.now() / 1000;
+          const remainingHrs = Math.floor(remainingSec / 3600);
+          const remainingMin = Math.floor((remainingSec % 3600) / 60);
+          if (remainingSec <= 0) {
+            warning("Token has already expired — will be refreshed on next request");
+          } else if (remainingSec < 3600) {
+            warning(`Token expires in ${remainingMin}m — consider refreshing soon`);
+          } else {
+            ok(`Token expires in ${remainingHrs}h ${remainingMin}m`);
+          }
+        }
       } catch (err: any) {
         error(`Token refresh failed: ${err.message}`);
         lines.push("", `── Summary ──`);
@@ -116,6 +164,23 @@ export function createHealthcheckCommand() {
         return { text: lines.join("\n") };
       }
 
+      // ── 2b. Version Negotiation ──
+      lines.push("", "── Version Negotiation ──");
+      const versionInfo = client.getLastVersionInfo();
+      if (versionInfo) {
+        info(`Hub latest: ${versionInfo.latest_plugin_version ?? "unknown"}, min: ${versionInfo.min_plugin_version ?? "unknown"}`);
+        const status = checkVersionInfo(versionInfo);
+        if (status === "incompatible") {
+          error(`Plugin ${PLUGIN_VERSION} is below minimum ${versionInfo.min_plugin_version} — update required`);
+        } else if (status === "update_available") {
+          warning(`New version ${versionInfo.latest_plugin_version} available (current: ${PLUGIN_VERSION})`);
+        } else {
+          ok(`Plugin ${PLUGIN_VERSION} is up to date`);
+        }
+      } else {
+        info("Hub did not return version info");
+      }
+
       // ── 3. Agent Resolution ──
       lines.push("", "── Agent Identity ──");
 
@@ -139,10 +204,34 @@ export function createHealthcheckCommand() {
       const mode = acct.deliveryMode || "websocket";
       ok(`Delivery mode: ${mode}`);
 
-      if (mode === "polling") {
+      if (mode === "websocket") {
+        const channelCfg = resolveChannelConfig(cfg);
+        const accounts = resolveAccounts(channelCfg);
+        const wsAccountId = Object.keys(accounts)[0] || "default";
+        const wsStatus = getWsStatus(wsAccountId);
+        const statusLabel = wsStatus === "authenticated" ? "connected (authenticated)" : wsStatus;
+        if (wsStatus === "authenticated") {
+          ok(`WebSocket: ${statusLabel}`);
+        } else if (wsStatus === "connecting" || wsStatus === "reconnecting") {
+          warning(`WebSocket: ${statusLabel}`);
+        } else {
+          error(`WebSocket: ${statusLabel}`);
+        }
+      } else if (mode === "polling") {
         info(`Poll interval: ${acct.pollIntervalMs || 5000}ms`);
       }
 
+      // ── 5. Notify Session ──
+      lines.push("", "── Notify Session ──");
+
+      const ns = acct.notifySession;
+      if (!ns || (Array.isArray(ns) && ns.length === 0)) {
+        warning("notifySession is not configured — contact requests and system notifications will not be forwarded to any owner channel");
+      } else {
+        const sessions = Array.isArray(ns) ? ns : [ns];
+        ok(`Notify session(s): ${sessions.join(", ")}`);
+      }
+
       // ── Summary ──
       lines.push("", "── Summary ──");
       const total = pass + warn + fail;
@@ -156,6 +245,16 @@ export function createHealthcheckCommand() {
         lines.push("", "All checks passed. BotCord is ready!");
       }
 
+      // Mark onboarding complete when no critical failures (warnings are acceptable —
+      // missing notifySession, available updates, etc. are non-blocking for onboarding)
+      if (fail === 0 && acct.credentialsFile) {
+        if (!isOnboarded(acct.credentialsFile)) {
+          if (markOnboarded(acct.credentialsFile)) {
+            lines.push("", "Onboarding complete — welcome to BotCord!");
+          }
+        }
+      }
+
       return { text: lines.join("\n") };
     },
   };

package/src/constants.ts

@@ -9,7 +9,7 @@
 
 export type ReleaseChannel = "stable" | "beta";
 
-export const RELEASE_CHANNEL: ReleaseChannel = "beta";
+export const RELEASE_CHANNEL: ReleaseChannel = "stable";
 
 const HUB_URLS: Record<ReleaseChannel, string> = {
   stable: "https://api.botcord.chat",

package/src/credentials.ts

@@ -17,6 +17,7 @@ export interface StoredBotCordCredentials {
   savedAt: string;
   token?: string;
   tokenExpiresAt?: number;
+  onboardedAt?: string;
 }
 
 function normalizeCredentialValue(raw: any, keys: string[]): string | undefined {
@@ -86,6 +87,8 @@ export function loadStoredCredentials(credentialsFile: string): StoredBotCordCre
     throw new Error(`BotCord credentials file "${resolved}" has an invalid hubUrl: ${err.message}`);
   }
 
+  const onboardedAt = normalizeCredentialValue(raw, ["onboardedAt", "onboarded_at"]);
+
   return {
     version: 1,
     hubUrl: normalizedHubUrl,
@@ -97,6 +100,7 @@ export function loadStoredCredentials(credentialsFile: string): StoredBotCordCre
     savedAt: savedAt || new Date().toISOString(),
     token,
     tokenExpiresAt,
+    onboardedAt,
   };
 }
 
@@ -164,6 +168,40 @@ export function updateCredentialsToken(
   }
 }
 
+/**
+ * Check whether the agent has completed onboarding.
+ */
+export function isOnboarded(credentialsFile: string): boolean {
+  const resolved = resolveCredentialsFilePath(credentialsFile);
+  try {
+    if (!existsSync(resolved)) return false;
+    const raw = JSON.parse(readFileSync(resolved, "utf8")) as Record<string, unknown>;
+    return !!(raw.onboardedAt || raw.onboarded_at);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Mark the agent as onboarded by writing onboardedAt timestamp.
+ */
+export function markOnboarded(credentialsFile: string): boolean {
+  const resolved = resolveCredentialsFilePath(credentialsFile);
+  try {
+    if (!existsSync(resolved)) return false;
+    const raw = JSON.parse(readFileSync(resolved, "utf8")) as Record<string, unknown>;
+    raw.onboardedAt = new Date().toISOString();
+    writeFileSync(resolved, JSON.stringify(raw, null, 2) + "\n", {
+      encoding: "utf8",
+      mode: 0o600,
+    });
+    chmodSync(resolved, 0o600);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Attach token persistence to a BotCordClient.
  * If the account was loaded from a credentialsFile, refreshed tokens

package/src/dynamic-context.ts

@@ -0,0 +1,77 @@
+/**
+ * BotCord dynamic context builder.
+ *
+ * Builds ephemeral context (cross-room digest, working memory, loop-risk)
+ * for injection via before_prompt_build hook's appendSystemContext.
+ *
+ * Using appendSystemContext (instead of the old prependContext) means:
+ *   - Content is NOT persisted to the session transcript
+ *   - Each turn gets fresh context, old context doesn't accumulate
+ *   - Content stays at system-prompt priority (not user-priority)
+ *   - Minor KV cache impact when content changes between turns
+ *
+ * Note: We considered using a Context Engine plugin (assemble() +
+ * systemPromptAddition) but that requires explicit slot activation
+ * via plugins.slots.contextEngine config. The hook approach works
+ * out of the box with zero config.
+ */
+import { buildCrossRoomDigest, getSessionRoom } from "./room-context.js";
+import { readWorkingMemory } from "./memory.js";
+import { buildWorkingMemoryPrompt } from "./memory-protocol.js";
+import {
+  buildBotCordLoopRiskPrompt,
+  shouldRunBotCordLoopRiskCheck,
+} from "./loop-risk.js";
+
+/**
+ * Build the dynamic context for a BotCord session.
+ * Returns appendSystemContext string, or null if no context needed.
+ *
+ * Called from the before_prompt_build hook in index.ts.
+ */
+export async function buildDynamicContext(params: {
+  sessionKey: string;
+  channelId?: string;
+  prompt?: string;
+  messages?: unknown[];
+  trigger?: string;
+}): Promise<string | null> {
+  const { sessionKey, channelId, prompt, messages, trigger } = params;
+
+  const isOwnerChat = sessionKey === "botcord:owner:main";
+  const isBotCordSession = isOwnerChat || !!getSessionRoom(sessionKey);
+
+  if (!isBotCordSession) return null;
+
+  const parts: string[] = [];
+
+  // 1. Cross-room activity digest
+  const digest = await buildCrossRoomDigest(sessionKey);
+  if (digest) parts.push(digest);
+
+  // 2. Working memory
+  try {
+    const wm = readWorkingMemory();
+    const memoryPrompt = buildWorkingMemoryPrompt({ workingMemory: wm });
+    parts.push(memoryPrompt);
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.warn("[botcord] dynamic-context: failed to read working memory:", msg);
+  }
+
+  // 3. Loop-risk guard
+  if (prompt && shouldRunBotCordLoopRiskCheck({
+    channelId: channelId ?? "botcord",
+    prompt,
+    trigger,
+  })) {
+    const loopRisk = buildBotCordLoopRiskPrompt({
+      prompt,
+      messages: messages ?? [],
+      sessionKey,
+    });
+    if (loopRisk) parts.push(loopRisk);
+  }
+
+  return parts.length > 0 ? parts.join("\n\n") : null;
+}