@xmoxmo/bncr 0.6.5 → 0.6.6

package/src/messaging/inbound/commands.ts

@@ -120,8 +120,49 @@ export async function handleBncrNativeCommand(params: {
 
   // Stop always goes through the unified stop fast path in dispatch.ts.
   // It is not a bncr native command and must never be processed here.
-  if (isBncrStopCommandText(extracted.text)) {
-    return { handled: false };
+  // Only exact `/stop` is accepted; any other `/stop*` form is rejected.
+  const rawStopText = String(extracted.text || '')
+    .trim()
+    .toLowerCase();
+  if (rawStopText.startsWith('/stop')) {
+    if (isBncrStopCommandText(extracted.text)) {
+      return { handled: false };
+    }
+    // Non-exact `/stop` forms (extra args, @bot suffix, or other extension)
+    // are rejected immediately so they never reach the agent.
+    const rejectedRoute = buildBncrNativeCommandResolvedRoute({
+      api,
+      cfg,
+      channelId,
+      accountId,
+      peer,
+      resolvedAgentId,
+    });
+    const { baseSessionKey, sessionKey } = buildBncrNativeCommandSessionState({
+      parsed,
+      sessionAgentId: rejectedRoute.agentId || canonicalAgentId,
+      resolvedRoute: rejectedRoute,
+    });
+    logBncrNativeCommandSummary(
+      buildBncrNativeCommandSummary({
+        kind: 'stop',
+        command: rawStopText,
+        accountId,
+        to: formatDisplayScope(route),
+        msgId: msgId || null,
+        result: 'rejected',
+      }),
+    );
+    await enqueueFromReply({
+      accountId,
+      sessionKey: baseSessionKey,
+      route,
+      payload: {
+        text: 'Only exact /stop is supported. Send /stop to stop.',
+        replyToId: msgId || undefined,
+      },
+    });
+    return { handled: true, command: 'stop', sessionKey };
   }
 
   const whitelistBareCommand =

package/src/messaging/inbound/conversation-history.ts

@@ -5,6 +5,7 @@ import {
   type HistoryEntry,
   type HistoryMediaEntry,
 } from 'openclaw/plugin-sdk/reply-history';
+import { normalizeAccountId } from '../../core/accounts.ts';
 import { formatOpenClawAgentEnvelope } from '../../openclaw/reply-runtime.ts';
 import type { BncrInboundApi } from './contracts.ts';
 import type { ParsedInbound } from './dispatch-prep.ts';
@@ -87,33 +88,53 @@ export function resolveBncrHistoryLimit(historyLimit?: number): number {
   return resolved >= 2 ? resolved : DEFAULT_HISTORY_LIMIT;
 }
 
-export function buildBncrConversationHistoryKey(parsed: ParsedInbound): string | null {
+export function buildBncrConversationHistoryKey(
+  parsed: ParsedInbound,
+  options?: { accountId?: string | null },
+): string | null {
   const platform = String(parsed.platform || '').trim();
   if (!platform) return null;
+  const accountId = normalizeAccountId(options?.accountId ?? parsed.accountId);
   if (parsed.peer.kind === 'group') {
     const groupId = String(parsed.groupId || '').trim();
     if (!groupId || groupId === '0') return null;
-    return `${platform}:${groupId}`;
+    return `${accountId}:${platform}:${groupId}`;
   }
   const userId = String(parsed.userId || '').trim();
   if (!userId || userId === '0') return null;
-  return `${platform}:${userId}`;
+  return `${accountId}:${platform}:${userId}`;
 }
 
 export function buildBncrConversationHistoryKeyFromRoute(args: {
+  accountId?: string | null;
   platform?: string;
   groupId?: string;
   userId?: string;
 }): string | null {
   const platform = String(args.platform || '').trim();
   if (!platform) return null;
+  const accountId = normalizeAccountId(args.accountId);
   const groupId = String(args.groupId || '0').trim() || '0';
   const userId = String(args.userId || '0').trim() || '0';
-  if (groupId !== '0') return `${platform}:${groupId}`;
-  if (userId !== '0') return `${platform}:${userId}`;
+  if (groupId !== '0') return `${accountId}:${platform}:${groupId}`;
+  if (userId !== '0') return `${accountId}:${platform}:${userId}`;
   return null;
 }
 
+/**
+ * Extract the scene key (platform:userId or platform:groupId) from a history
+ * key that may contain an accountId prefix. Legacy scene-only keys pass
+ * through unchanged.
+ */
+export function resolveBncrSceneKeyFromHistoryKey(historyKey: string): string {
+  const key = String(historyKey || '').trim();
+  const firstColon = key.indexOf(':');
+  if (firstColon > 0 && key.indexOf(':', firstColon + 1) !== -1) {
+    return key.slice(firstColon + 1);
+  }
+  return key;
+}
+
 export function resolveBncrConversationHistoryMessageId(parsed: ParsedInbound): string | undefined {
   const msgId = String(parsed.msgId || '').trim();
   return msgId || undefined;

package/src/messaging/inbound/native-command.ts

@@ -57,9 +57,9 @@ export type NativeSessionResetCommand = {
  * the same code path as an admin caller. This whitelist is shared
  * across permission checks so admin and non-admin logic stay in sync.
  *
- * `stop` stays in this whitelist for semantic consistency, but it is
- * routed through the unified stop fast path in dispatch.ts rather than
- * the native command handler, so it is never processed here.
+ * `stop` is intentionally absent: it is handled before this set by the
+ * unified stop fast path in dispatch.ts, and `isBncrStopCommandText` only
+ * accepts the exact `/stop` form.
  */
 export const BNCR_SELF_SERVICE_COMMANDS: ReadonlySet<string> = new Set([
   'whoami',
@@ -68,7 +68,6 @@ export const BNCR_SELF_SERVICE_COMMANDS: ReadonlySet<string> = new Set([
   'model',
   'new',
   'reset',
-  'stop',
 ]);
 
 /**
@@ -136,13 +135,7 @@ export const BNCR_NATIVE_COMMANDS = new Set([
   'download-media',
 ]);
 
-export const BNCR_DIRECT_ALLOWED_BARE_COMMANDS = new Set([
-  'whoami',
-  'status',
-  'new',
-  'reset',
-  'stop',
-]);
+export const BNCR_DIRECT_ALLOWED_BARE_COMMANDS = new Set(['whoami', 'status', 'new', 'reset']);
 
 export const BNCR_DIRECT_ALLOWED_SUBCOMMANDS = new Set([
   'help',
@@ -340,6 +333,9 @@ export function resolveBncrNativeSessionResetCommand(args: {
   peerKind: 'direct' | 'group';
 }): NativeSessionResetCommand | null {
   if (args.command.command !== 'new' && args.command.command !== 'reset') return null;
+  // new/reset are exact session-reset commands. Extra arguments are not
+  // valid and must not silently reset or create a session.
+  if (String(args.command.argsText || '').trim()) return null;
   const reason = args.command.command === 'new' ? 'new' : 'reset';
   return {
     handled: true,

package/src/messaging/inbound/outbound-replay-cache.ts

@@ -1,3 +1,4 @@
+import { normalizeAccountId } from '../../core/accounts.ts';
 import type {
   BncrOutboundReplayEntry,
   BncrOutboundReplayMediaEntry,
@@ -66,7 +67,7 @@ export function buildBncrOutboundReplayKeyFromRoute(args: {
   groupId?: string;
   userId?: string;
 }): string | null {
-  const accountId = String(args.accountId || '').trim() || 'default';
+  const accountId = normalizeAccountId(args.accountId);
   const platform = String(args.platform || '').trim();
   const groupId = String(args.groupId || '0').trim() || '0';
   const userId = String(args.userId || '0').trim() || '0';
@@ -167,6 +168,18 @@ export type BncrOutboundReplayRecordResult = {
   historyVersion?: number;
 };
 
+/**
+ * Record an outbound bot reply into both the conversation-history window and
+ * the outbound-replay cache.
+ *
+ * Dual-write strategy: the conversation-history window is the canonical
+ * ordered source for structured context (conversation_context). The
+ * outbound-replay cache is a lighter, indexed copy used by bridge-facing
+ * queries such as `listRecentOutbound`. Both are kept in sync for the
+ * duration of the runtime session. This is a compatibility design; the
+ * cache may be retired once all read paths are migrated to the history
+ * window.
+ */
 export function recordBncrOutboundReplay(args: {
   cache: BncrOutboundReplayCache;
   conversationHistories?: BncrConversationHistoryMap;
@@ -200,6 +213,7 @@ export function recordBncrOutboundReplay(args: {
   if (!body) return { recorded: false, historyOverflow: false };
   const recordTimestamp = args.entry.lastPushAt ?? Date.now();
   const historyKey = buildBncrConversationHistoryKeyFromRoute({
+    accountId: args.entry.accountId,
     platform: args.entry.route?.platform,
     groupId: args.entry.route?.groupId,
     userId: args.entry.route?.userId,
@@ -347,7 +361,9 @@ export function readBncrOutboundReplaySnapshot(args: {
     : [];
   if (!args.conversationHistories) return legacyEntries;
 
-  const historyKey = buildBncrConversationHistoryKey(args.parsed);
+  const historyKey = buildBncrConversationHistoryKey(args.parsed, {
+    accountId: args.accountId,
+  });
   const historyEntries = historyKey
     ? (args.conversationHistories.get(historyKey) || [])
         .filter((entry) => entry.role === 'assistant')

package/src/messaging/inbound/reply-dispatch.ts

@@ -247,6 +247,14 @@ export async function runBncrInboundReplyDispatch(args: {
                     sessionMetaBarrier.track(task);
                   },
                 },
+                // OpenClaw ≥8.1 requires prepared turns to carry a runDispatchLifecycle
+                // shim. Bncr dispatches directly via runDispatch and does not participate
+                // in the adoption lifecycle, so turnAdoptionLifecycle is intentionally
+                // left as undefined; onDispatchSkipped is a safe no-op here.
+                runDispatchLifecycle: {
+                  turnAdoptionLifecycle: undefined,
+                  onDispatchSkipped: async () => {},
+                },
                 runDispatch: async () => {
                   await sessionMetaBarrier.wait();
                   await correctBncrInboundSessionLabel({

package/src/openclaw/session-reset-runtime.ts

@@ -1,4 +1,5 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { dirname, join } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
@@ -12,7 +13,7 @@ type SessionResetParams = {
 type SessionResetFn = (params: SessionResetParams) => Promise<SessionResetResult>;
 
 let testOverride: SessionResetFn | null = null;
-let resolvedSessionRuntimeUrlCache: string | null = null;
+let resolvedSessionResetRuntimeCache: SessionResetFn | null = null;
 
 export function setBncrSessionResetRuntimeForTest(fn: SessionResetFn | null): () => void {
   const previous = testOverride;
@@ -22,56 +23,103 @@ export function setBncrSessionResetRuntimeForTest(fn: SessionResetFn | null): ()
   };
 }
 
-function resolveOpenClawSessionsRuntimeUrl(): string {
-  if (resolvedSessionRuntimeUrlCache) return resolvedSessionRuntimeUrlCache;
-  let current = dirname(fileURLToPath(import.meta.url));
-  let pluginRoot: string | null = null;
+function findPackageRoot(startPath: string, packageName: string): string | null {
+  let current = dirname(startPath);
   while (true) {
     const pkgPath = join(current, 'package.json');
     try {
       const pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) as { name?: string };
-      if (pkg.name === '@xmoxmo/bncr') {
-        pluginRoot = current;
-        break;
-      }
+      if (pkg.name === packageName) return current;
     } catch {
-      // Keep walking up toward the plugin root.
+      // Keep walking toward the package root.
     }
     const parent = dirname(current);
-    if (parent === current) break;
+    if (parent === current) return null;
     current = parent;
   }
-  if (!pluginRoot) {
-    throw new Error('bncr plugin root not found for session reset runtime');
+}
+
+function resolveOpenClawDistDir(): string {
+  let current = dirname(fileURLToPath(import.meta.url));
+  let resolvedOpenClawEntry: string | null = null;
+  try {
+    resolvedOpenClawEntry = createRequire(import.meta.url).resolve('openclaw');
+  } catch {
+    // Fall back to the plugin-local dependency path below.
   }
 
-  // Try candidate paths for the sessions runtime re-export file.
-  // The hash-stamped bundle name may change across OpenClaw releases, so we
-  // first try the stable re-export entry and fall back to the known hash.
-  const candidates = [
-    join(pluginRoot, 'node_modules', 'openclaw', 'dist', 'sessions.runtime.js'),
-    join(pluginRoot, 'node_modules', 'openclaw', 'dist', 'sessions.runtime-BQwwkuFq.js'),
-  ];
-  for (const target of candidates) {
-    if (existsSync(target)) {
-      resolvedSessionRuntimeUrlCache = pathToFileURL(target).href;
-      return resolvedSessionRuntimeUrlCache;
+  const openClawRoot = resolvedOpenClawEntry
+    ? findPackageRoot(resolvedOpenClawEntry, 'openclaw')
+    : null;
+  if (openClawRoot) {
+    const distDir = join(openClawRoot, 'dist');
+    if (existsSync(distDir)) return distDir;
+  }
+
+  while (true) {
+    const pluginRoot = findPackageRoot(current, '@xmoxmo/bncr');
+    if (pluginRoot) {
+      const distDir = join(pluginRoot, 'node_modules', 'openclaw', 'dist');
+      if (existsSync(distDir)) return distDir;
     }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
   }
+
+  const resolvedPath = resolvedOpenClawEntry || '(unresolved)';
+  const pluginPath = join(
+    dirname(fileURLToPath(import.meta.url)),
+    'node_modules',
+    'openclaw',
+    'dist',
+  );
   throw new Error(
-    `OpenClaw sessions runtime not found under ${join(pluginRoot, 'node_modules', 'openclaw', 'dist')}`,
+    `OpenClaw dist directory not found (resolved entry: ${resolvedPath}; plugin fallback: ${pluginPath})`,
   );
 }
 
+function resolveOpenClawSessionsRuntimeUrls(): string[] {
+  const distDir = resolveOpenClawDistDir();
+  if (!existsSync(distDir)) {
+    throw new Error(`OpenClaw dist directory not found: ${distDir}`);
+  }
+
+  // Scan dist for sessions.runtime*.js, preferring the stable re-export.
+  const candidates = readdirSync(distDir)
+    .filter((name) => /^sessions\.runtime(?:-[A-Za-z0-9_-]+)?\.js$/.test(name))
+    .sort(
+      (a, b) =>
+        Number(b === 'sessions.runtime.js') - Number(a === 'sessions.runtime.js') ||
+        a.localeCompare(b),
+    );
+  return candidates.map((name) => pathToFileURL(join(distDir, name)).href);
+}
+
 export async function performBncrGatewaySessionReset(
   params: SessionResetParams,
 ): Promise<SessionResetResult> {
   if (testOverride) return testOverride(params);
-  const mod = (await import(resolveOpenClawSessionsRuntimeUrl())) as {
-    performGatewaySessionReset?: SessionResetFn;
-  };
-  if (typeof mod.performGatewaySessionReset !== 'function') {
-    throw new Error('OpenClaw performGatewaySessionReset is unavailable');
+  if (!resolvedSessionResetRuntimeCache) {
+    const candidates = resolveOpenClawSessionsRuntimeUrls();
+    const importErrors: string[] = [];
+    for (const url of candidates) {
+      try {
+        const mod = (await import(url)) as { performGatewaySessionReset?: SessionResetFn };
+        if (typeof mod.performGatewaySessionReset === 'function') {
+          resolvedSessionResetRuntimeCache = mod.performGatewaySessionReset;
+          break;
+        }
+        importErrors.push(`${url}: export unavailable`);
+      } catch (error) {
+        importErrors.push(`${url}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    if (!resolvedSessionResetRuntimeCache) {
+      throw new Error(
+        `OpenClaw performGatewaySessionReset is unavailable; candidates: ${importErrors.join('; ') || '(none)'}`,
+      );
+    }
   }
-  return mod.performGatewaySessionReset(params);
+  return resolvedSessionResetRuntimeCache(params);
 }

package/src/plugin/channel-runtime-types.ts

@@ -86,7 +86,7 @@ export type BncrPersistedConversationHistoryEntry = {
 export type BncrPersistedConversationHistoryMediaEntry = {
   path?: string;
   contentType?: string;
-  kind?: 'image' | 'video' | 'audio' | 'document' | 'unknown';
+  kind?: 'image' | 'video' | 'audio' | 'document' | 'sticker' | 'unknown';
   messageId?: string;
 };
 

package/src/plugin/sqlite-state.ts

@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
 import { DatabaseSync } from 'node:sqlite';
+import { BNCR_DEFAULT_ACCOUNT_ID, normalizeAccountId } from '../core/accounts.ts';
 import {
   dumpRegisterDriftSnapshot,
   normalizeRegisterDriftSnapshot,
@@ -776,19 +777,43 @@ function loadControlState(db: DatabaseSync): BncrSqliteControlState {
 }
 
 function deriveHistoryKeyFromRoute(args: {
+  accountId?: string | null;
   platform?: string;
   groupId?: string;
   userId?: string;
 }): string | null {
+  const accountId = normalizeAccountId(args.accountId);
   const platform = String(args.platform || '').trim();
   const groupId = String(args.groupId || '0').trim() || '0';
   const userId = String(args.userId || '0').trim() || '0';
   if (!platform) return null;
-  if (groupId !== '0') return `${platform}:${groupId}`;
-  if (userId !== '0') return `${platform}:${userId}`;
+  if (groupId !== '0') return `${accountId}:${platform}:${groupId}`;
+  if (userId !== '0') return `${accountId}:${platform}:${userId}`;
   return null;
 }
 
+function normalizePersistedHistoryKey(key: string): string {
+  const raw = String(key || '').trim();
+  if (!raw) return raw;
+  const firstColon = raw.indexOf(':');
+  const secondColon = raw.indexOf(':', firstColon + 1);
+  if (firstColon <= 0 || secondColon < 0) return `${BNCR_DEFAULT_ACCOUNT_ID}:${raw}`;
+  return `${normalizeAccountId(raw.slice(0, firstColon))}:${raw.slice(firstColon + 1)}`;
+}
+
+function resolvePersistedHistoryAccountId(key: string): string {
+  const normalized = normalizePersistedHistoryKey(key);
+  const separator = normalized.indexOf(':');
+  return normalizeAccountId(separator > 0 ? normalized.slice(0, separator) : undefined);
+}
+
+function resolvePersistedHistoryKey(key: string, accountId: string): string {
+  const normalized = normalizePersistedHistoryKey(key);
+  const separator = normalized.indexOf(':');
+  const sceneKey = separator > 0 ? normalized.slice(separator + 1) : normalized;
+  return `${normalizeAccountId(accountId)}:${sceneKey}`;
+}
+
 function parseMediaJson(value: string) {
   try {
     const parsed = JSON.parse(value ?? '[]');
@@ -861,7 +886,7 @@ function replaceHistoryMessages(
     const seenReplayMessageIds = new Map<string, Set<string>>();
 
     for (const bucket of historyBuckets) {
-      const historyKey = String(bucket.key || '').trim();
+      const historyKey = normalizePersistedHistoryKey(String(bucket.key || '').trim());
       if (!historyKey) continue;
       for (const entry of Array.isArray(bucket.entries) ? bucket.entries : []) {
         const sender = String(entry?.sender || '').trim();
@@ -909,12 +934,22 @@ function replaceHistoryMessages(
     }
 
     for (const bucket of replayBuckets) {
-      const bufferKey = String(bucket.key || '').trim();
-      if (!bufferKey) continue;
+      const bucketKey = normalizePersistedHistoryKey(String(bucket.key || '').trim());
+      if (!bucketKey) continue;
       for (const entry of Array.isArray(bucket.entries) ? bucket.entries : []) {
         const sender = String(entry?.sender || '').trim();
         const body = String(entry?.body || '').trim();
         if (!sender || !body) continue;
+        const entryAccountId = entry.accountId
+          ? normalizeAccountId(entry.accountId)
+          : resolvePersistedHistoryAccountId(bucketKey);
+        const routeHistoryKey = deriveHistoryKeyFromRoute({
+          accountId: entryAccountId,
+          platform: entry.route?.platform,
+          groupId: entry.route?.groupId,
+          userId: entry.route?.userId,
+        });
+        const bufferKey = routeHistoryKey || resolvePersistedHistoryKey(bucketKey, entryAccountId);
         if (entry.messageId) {
           const seen = seenReplayMessageIds.get(bufferKey) ?? new Set<string>();
           if (seen.has(entry.messageId)) continue;
@@ -930,16 +965,12 @@ function replaceHistoryMessages(
         if (entry.messageId && isConsumedReplayMessage.get(bufferKey, entry.messageId)) {
           continue;
         }
-        const historyKey = deriveHistoryKeyFromRoute({
-          platform: entry.route?.platform,
-          groupId: entry.route?.groupId,
-          userId: entry.route?.userId,
-        });
+        const historyKey = routeHistoryKey || bufferKey;
         insert.run(
           'replay',
           historyKey ?? '',
           bufferKey,
-          entry.accountId ?? null,
+          entryAccountId,
           sender,
           entry.senderId ?? null,
           'assistant',
@@ -1807,13 +1838,23 @@ export function createBncrSqliteStateDatabase(
   }
 
   function normalizeHistoryKeySkipList(skipHistoryKeys: readonly string[] | undefined): string[] {
-    return Array.from(
-      new Set(
-        (skipHistoryKeys ?? [])
-          .map((key) => String(key || '').trim())
-          .filter((key) => Boolean(key)),
-      ),
-    );
+    const normalized: string[] = [];
+    for (const rawKey of skipHistoryKeys ?? []) {
+      const key = String(rawKey || '').trim();
+      if (!key) continue;
+      normalized.push(key);
+      const legacyKey = toLegacyHistoryKey(key);
+      if (legacyKey && legacyKey !== key) normalized.push(legacyKey);
+    }
+    return Array.from(new Set(normalized));
+  }
+
+  function toLegacyHistoryKey(historyKey: string): string {
+    const firstColon = historyKey.indexOf(':');
+    if (firstColon <= 0) return '';
+    const secondColon = historyKey.indexOf(':', firstColon + 1);
+    if (secondColon <= firstColon + 1) return '';
+    return historyKey.slice(firstColon + 1);
   }
 
   function buildHistoryKeySkipCondition(skipped: readonly string[]): string {