@clawling/clawchat-plugin-openclaw 2026.10.11-2 → 2026.10.13-1

package/src/runtime.ts

@@ -36,7 +36,7 @@ import {
   type LivewareSampleSupervisorDeps,
 } from "./liveware-sample.ts";
 import { ClawlingApiError } from "./api-types.ts";
-import { RefreshManager } from "./refresh-manager.ts";
+import { RefreshManager, fingerprintRefreshToken, type RevokedRefreshMarker } from "./refresh-manager.ts";
 import { RECONNECT_GUIDE_URL } from "./onboarding-context.ts";
 import {
   runOpenclawClawlingLogin,
@@ -143,6 +143,9 @@ type RuntimeConnectionStore = Pick<
       | "upsertActivation"
       | "rotateActivationTokens"
       | "clearActivationCredentials"
+      | "getRevokedRefreshMarker"
+      | "setRevokedRefreshMarker"
+      | "clearRevokedRefreshMarker"
       | "insertMessage"
       | "claimMessageOnce"
       | "markMessageAcknowledged"
@@ -279,20 +282,27 @@ export function classifyHelloFailReason(
  * carries no `token` of its own (i.e. the access token itself came from
  * `CLAWCHAT_TOKEN`) — an env-provisioned pair can rotate, while a login-written
  * token is never paired with a stray refresh token left in the environment.
+ * A revoked marker also excludes a matching refresh fingerprint from either source.
  */
 function readConfigRefreshToken(
   cfg: OpenClawConfig,
   accountId: string,
+  revokedMarker?: RevokedRefreshMarker | null,
   env: NodeJS.ProcessEnv = process.env,
 ): string | null {
   const section = readOpenclawClawlingAccountSection(cfg, accountId);
   const refreshToken = section.refreshToken;
-  if (typeof refreshToken === "string" && refreshToken.trim()) return refreshToken.trim();
+  const usable = (token: unknown): string | null => {
+    const value = typeof token === "string" ? token.trim() : "";
+    return value && (!revokedMarker || fingerprintRefreshToken(value) !== revokedMarker.fingerprint)
+      ? value : null;
+  };
+  if (typeof refreshToken === "string" && refreshToken.trim()) return usable(refreshToken);
   if (normalizeOpenclawClawlingAccountId(accountId) !== DEFAULT_ACCOUNT_ID) return null;
   const configToken = section.token;
   if (typeof configToken === "string" && configToken.trim()) return null;
   const envRefreshToken = env[CLAWCHAT_REFRESH_TOKEN_ENV];
-  return typeof envRefreshToken === "string" && envRefreshToken.trim() ? envRefreshToken.trim() : null;
+  return usable(envRefreshToken);
 }
 
 function withFullVerboseDispatchConfig(cfg: OpenClawConfig, agentId: string): OpenClawConfig {
@@ -367,6 +377,24 @@ function isOpenClawConfirmSlashCommand(rawBody: string): boolean {
   return Boolean(name && OPENCLAW_CONFIRM_SLASH_COMMANDS.has(name));
 }
 
+// Group commands that start an agent turn (OpenClaw 2026.9.8 command
+// handlers): their output is the conversation itself, so it stays in the group
+// with no ✅. `/new <text>` and `/reset <text>` run the text as a prompt.
+const AGENT_TURN_GROUP_COMMANDS = new Set(["btw", "dashboard", "goal", "learn", "loop", "steer", "tell"]);
+
+function opensAgentTurn(commandText: string): boolean {
+  const name = parseSlashCommandName(commandText);
+  if (!name) return false;
+  if (AGENT_TURN_GROUP_COMMANDS.has(name)) return true;
+  const hasArgs = /\s\S/.test(commandText.trim());
+  return (name === "new" || name === "reset") && hasArgs;
+}
+
+/** First line of the owner's direct-chat receipt for a group command. */
+export function ownerCommandReceiptHeader(groupTitle: string, commandText: string): string {
+  return `From group "${groupTitle}": ${commandText.trim()}`;
+}
+
 function isOpenClawTextSlashCommand(rawBody: string, cfg: OpenClawConfig): boolean {
   return Boolean(parseSlashCommandName(rawBody) && (
     hasControlCommand(rawBody, cfg)
@@ -637,7 +665,9 @@ export interface StartGatewayParams {
    * min-interval floor) actually constrain a cross-reconnect refresh loop instead
    * of resetting on every fresh `RefreshManager`.
    */
-  refreshManagerState?: { rejectedToken: string | null; lastAttemptAt: number };
+  refreshManagerState?: Parameters<RefreshManager["restoreState"]>[0];
+  /** Internal guard when durable marker writes fail; never contains credentials. */
+  revokedRefreshMarker?: RevokedRefreshMarker;
   /**
    * Internal — the live (possibly rotated) refresh token, carried across a
    * §D/§B gateway re-enter. A rotation persists config with `afterWrite:{mode:
@@ -972,6 +1002,7 @@ function waitForActivationPoll(abortSignal: AbortSignal, ms: number): Promise<bo
 }
 
 async function waitForActivationCredentials(params: {
+  cfg: OpenClawConfig;
   account: ResolvedOpenclawClawlingAccount;
   abortSignal: AbortSignal;
   getStatus: () => ChannelAccountSnapshot;
@@ -980,16 +1011,23 @@ async function waitForActivationCredentials(params: {
   log?: Log;
   pollIntervalMs: number;
   rejectedActivationToken?: string;
+  revokedRefreshMarker?: RevokedRefreshMarker | null;
 }): Promise<{ account: ResolvedOpenclawClawlingAccount; source: "configured" | "sqlite" } | null> {
   const { abortSignal, getStatus, setStatus, store, log } = params;
   const accountId = params.account.accountId;
+  const revoked = params.revokedRefreshMarker;
+  const usable = (credentials: { accessToken: string; refreshToken: string | null }): boolean =>
+    credentials.accessToken !== params.rejectedActivationToken &&
+    (!revoked || (!!credentials.refreshToken &&
+      fingerprintRefreshToken(credentials.refreshToken) !== revoked.fingerprint));
   // SQLite-first: activation and token rotation persist to the activations
   // row, so a complete row is the durable credential source of truth even
   // when channel config/env also carries credentials. Config/env credentials
-  // only bootstrap the no-row case (the caller seeds a row from them).
+  // bootstrap the no-row case, or replace a revoked pair with a different
+  // refresh fingerprint (the caller seeds a row from the adopted pair).
   if (store?.getActivationCredentials) {
     const stored = store.getActivationCredentials({ platform: "openclaw", accountId });
-    if (stored && stored.accessToken !== params.rejectedActivationToken) {
+    if (stored && usable(stored)) {
       log?.info?.(
         `[${accountId}] clawchat-plugin-openclaw loaded activation credentials from sqlite`,
       );
@@ -1005,10 +1043,19 @@ async function waitForActivationCredentials(params: {
       };
     }
   }
-  if (accountHasConnectCredentials(params.account)) {
-    return { account: params.account, source: "configured" };
+  const configuredCredentials = (account: ResolvedOpenclawClawlingAccount) => {
+    const refreshToken = readConfigRefreshToken(params.cfg, accountId, revoked);
+    return accountHasConnectCredentials(account) && usable({ accessToken: account.token, refreshToken })
+      ? { account, source: "configured" as const } : null;
+  };
+  const configured = configuredCredentials(params.account);
+  if (configured) return configured;
+  if (revoked) {
+    log?.error?.(`[${accountId}] clawchat-plugin-openclaw ${CLAWCHAT_TOKEN_EXPIRED_MESSAGE}`);
+    setStatus({ ...getStatus(), connected: false, configured: false, running: false,
+      lastError: CLAWCHAT_TOKEN_EXPIRED_LAST_ERROR });
   }
-  if (!store?.getActivationCredentials) {
+  if (!revoked && !store?.getActivationCredentials) {
     const message = "Clawling Chat token is missing and activation database is unavailable";
     log?.error?.(`[${accountId}] clawchat-plugin-openclaw ${message}`);
     setStatus({
@@ -1024,7 +1071,7 @@ async function waitForActivationCredentials(params: {
   log?.info?.(
     `[${accountId}] clawchat-plugin-openclaw waiting for activation credentials in sqlite`,
   );
-  setStatus({
+  if (!revoked) setStatus({
     ...getStatus(),
     connected: false,
     configured: true,
@@ -1033,22 +1080,9 @@ async function waitForActivationCredentials(params: {
   });
 
   while (!abortSignal.aborted) {
-    const credentials = store.getActivationCredentials({
-      platform: "openclaw",
-      accountId,
-    });
-    if (credentials) {
-      if (credentials.accessToken === params.rejectedActivationToken) {
-        log?.debug?.(
-          `[${accountId}] clawchat-plugin-openclaw activation credential poll heartbeat status=rejected_token_unchanged intervalMs=${params.pollIntervalMs}`,
-        );
-        const shouldContinue = await waitForActivationPoll(abortSignal, params.pollIntervalMs);
-        if (!shouldContinue) break;
-        continue;
-      }
-      log?.info?.(
-        `[${accountId}] clawchat-plugin-openclaw loaded activation credentials from sqlite`,
-      );
+    const credentials = store?.getActivationCredentials?.({ platform: "openclaw", accountId });
+    if (credentials && usable(credentials)) {
+      log?.info?.(`[${accountId}] clawchat-plugin-openclaw loaded activation credentials from sqlite`);
       return {
         source: "sqlite",
         account: {
@@ -1060,8 +1094,14 @@ async function waitForActivationCredentials(params: {
         },
       };
     }
+    if (revoked) {
+      // Re-read env credentials while parked so a new pair can recover without
+      // another gateway invocation. Config credentials use the supplied snapshot.
+      const replacement = configuredCredentials(resolveOpenclawClawlingAccount(params.cfg, accountId));
+      if (replacement) return replacement;
+    }
     log?.debug?.(
-      `[${accountId}] clawchat-plugin-openclaw activation credential poll heartbeat status=waiting intervalMs=${params.pollIntervalMs}`,
+      `[${accountId}] clawchat-plugin-openclaw activation credential poll heartbeat status=${credentials ? "rejected_token_unchanged" : "waiting"} intervalMs=${params.pollIntervalMs}`,
     );
     const shouldContinue = await waitForActivationPoll(abortSignal, params.pollIntervalMs);
     if (!shouldContinue) break;
@@ -1079,7 +1119,25 @@ async function waitForActivationCredentials(params: {
 let warnedBelowHostFloor = false;
 let loggedHostToolSearch = false;
 
+/** Re-pair lifecycle owned by one gateway invocation (see performAutoLogout). */
+type GatewayLifecycle = { rePairWait?: Promise<void> };
+
 export async function startOpenclawClawlingGateway(params: StartGatewayParams): Promise<void> {
+  // Every exit, including an interrupted connect or abort during logout, must
+  // wait for the one re-pair lifecycle this invocation started: settling the
+  // host's startAccount task early would make the host restart the channel.
+  const lifecycle: GatewayLifecycle = {};
+  try {
+    await runOpenclawClawlingGateway(params, lifecycle);
+  } finally {
+    await lifecycle.rePairWait;
+  }
+}
+
+async function runOpenclawClawlingGateway(
+  params: StartGatewayParams,
+  lifecycle: GatewayLifecycle,
+): Promise<void> {
   const { cfg, abortSignal, setStatus, getStatus, log } = params;
   let account = params.account;
   // Obtain PluginRuntime from the stored runtime set via setOpenclawClawlingRuntime.
@@ -1144,7 +1202,10 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
       log,
     });
   }
+  const revokedRefreshMarker = params.revokedRefreshMarker ??
+    store?.getRevokedRefreshMarker?.({ platform: "openclaw", accountId });
   const activationAccount = await waitForActivationCredentials({
+    cfg,
     account,
     abortSignal,
     getStatus,
@@ -1153,9 +1214,15 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
     log,
     pollIntervalMs: params.activationPollIntervalMs ?? ACTIVATION_CREDENTIAL_POLL_INTERVAL_MS,
     rejectedActivationToken: params.rejectedActivationToken,
+    revokedRefreshMarker,
   });
   if (!activationAccount) return;
   account = activationAccount.account;
+  // Reset in-memory refresh guards only after adopting a different pair.
+  if (revokedRefreshMarker) {
+    params = { ...params, revokedRefreshMarker: undefined, refreshTokenOverride: undefined,
+      refreshManagerState: undefined, rejectedActivationToken: undefined };
+  }
   // Config/env bootstrap seeding: converge on SQLite as the single durable
   // credential store, so token rotation always has a row to update and the
   // next startup resolves SQLite-first to the same credentials.
@@ -1167,7 +1234,7 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
         userId: account.userId,
         ownerUserId: account.ownerUserId,
         accessToken: account.token,
-        refreshToken: readConfigRefreshToken(cfg, accountId),
+        refreshToken: readConfigRefreshToken(cfg, accountId, revokedRefreshMarker),
         loginMethod: "config-seed",
         deviceId: CHANNEL_ID,
       });
@@ -1177,6 +1244,11 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
       );
     }
   }
+  if (revokedRefreshMarker && store) {
+    if (store.clearRevokedRefreshMarker?.({ platform: "openclaw", accountId }) !== true) {
+      log?.warn?.(`[${accountId}] clawchat-plugin-openclaw failed to clear sqlite revoked marker after activation`);
+    }
+  }
   // Paired: link the report row via the authenticated endpoint, reusing the
   // SAME frozen device_id so the backend upserts the existing unpaired row.
   void reportPluginVersionSafe({
@@ -1373,13 +1445,13 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
   // blanks them (auto-logout); otherwise persists the rotated pair.
   const persistConfigTokens = async (
     tokens: { accessToken: string; refreshToken: string } | null,
-  ): Promise<void> => {
+  ): Promise<boolean> => {
     const mutateConfigFile = resolveMutateConfigFile();
     if (!mutateConfigFile) {
       log?.error?.(
         `[${accountId}] clawchat-plugin-openclaw config persistence unavailable; cannot ${tokens ? "rotate" : "clear"} tokens in config`,
       );
-      return;
+      return false;
     }
     await mutateConfigFile({
       afterWrite: { mode: "none", reason: "clawchat-plugin-openclaw token refresh" },
@@ -1393,6 +1465,7 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
         );
       },
     });
+    return true;
   };
 
   let lastHelloFailTraceId = "-";
@@ -1414,6 +1487,8 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
   let reconnectWithRefreshedToken = false;
   // §C — set once auto-logout has fired so we don't double-emit or reconnect.
   let autoLoggedOut = false;
+  let refreshClient: ClawlingChatClient | undefined;
+  let autoLogoutCleanup: Promise<void> | undefined;
 
   // §E — connect-time device id for `X-Device-Id` on refresh. Prefer the value
   // recorded in SQLite at connect; backfill legacy rows (no column) to the
@@ -1426,37 +1501,62 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
   // §C — auto-logout on permanent refresh failure. Blank creds in BOTH stores
   // (KEEP identity), flip not-configured via the auth-failure status path, and
   // emit the user-visible message. Idempotent.
-  const performAutoLogout = async (info: { code: number; message: string }): Promise<void> => {
-    if (autoLoggedOut) return;
+  const performAutoLogout = (
+    info: { code: number; message: string }, marker: RevokedRefreshMarker,
+  ): Promise<void> => {
+    if (autoLogoutCleanup) return autoLogoutCleanup;
     autoLoggedOut = true;
     log?.error?.(
       `[${accountId}] clawchat-plugin-openclaw auto-logout (token permanently expired) code=${info.code}: ${info.message}`,
     );
-    // SQLite: blank access/refresh, keep user/owner/device for re-pair.
-    if (store?.clearActivationCredentials) {
-      recordConnection("clear activation credentials", () =>
-        store.clearActivationCredentials?.({ platform: "openclaw", accountId }),
-      );
-    }
-    // Config: blank token/refreshToken keys.
-    try {
-      await persistConfigTokens(null);
-    } catch (err) {
-      log?.error?.(
-        `[${accountId}] clawchat-plugin-openclaw failed to clear config credentials on auto-logout: ${err instanceof Error ? err.message : String(err)}`,
-      );
-    }
-    // Flip not-configured (existing auth-failure status path) with the re-pair
-    // hint as `lastError`.
-    setStatus({
-      ...getStatus(),
-      connected: false,
-      configured: false,
-      running: false,
-      lastError: CLAWCHAT_TOKEN_EXPIRED_LAST_ERROR,
-    });
-    // User-visible notification (in addition to logs). Best-effort; never throws.
-    emitUserVisibleAuthLogout();
+    refreshManager.stop();
+    activeClients.delete(accountId);
+    try { refreshClient?.close(); } catch { /* Best effort shutdown. */ }
+    // Write the marker independently BEFORE clearing, so a failed clear cannot
+    // resurrect this rejected credential at the next process start.
+    autoLogoutCleanup = (async () => {
+      const markerInput = { platform: "openclaw", accountId, ...marker };
+      try {
+        if (store?.setRevokedRefreshMarker?.(markerInput) !== true) {
+          log?.warn?.(`[${accountId}] clawchat-plugin-openclaw failed to persist sqlite revoked refresh marker`);
+        }
+      } catch {
+        log?.warn?.(`[${accountId}] clawchat-plugin-openclaw failed to persist sqlite revoked refresh marker`);
+      }
+      try {
+        if (store?.clearActivationCredentials?.({ platform: "openclaw", accountId }) !== true) {
+          log?.warn?.(`[${accountId}] clawchat-plugin-openclaw failed to clear sqlite credentials on auto-logout`);
+        }
+      } catch {
+        log?.warn?.(`[${accountId}] clawchat-plugin-openclaw failed to clear sqlite credentials on auto-logout`);
+      }
+      try {
+        if (!await persistConfigTokens(null)) throw new Error("config mutation unavailable");
+      } catch {
+        log?.warn?.(`[${accountId}] clawchat-plugin-openclaw failed to clear config credentials on auto-logout`);
+      }
+      // Flip not-configured (existing auth-failure status path) with the re-pair
+      // hint as `lastError`.
+      setStatus({
+        ...getStatus(),
+        connected: false,
+        configured: false,
+        running: false,
+        lastError: CLAWCHAT_TOKEN_EXPIRED_LAST_ERROR,
+      });
+      // User-visible notification (in addition to logs). Best-effort; never throws.
+      emitUserVisibleAuthLogout();
+    })();
+    // Assign the lifetime before yielding, including when config clearing is
+    // still pending and closing the old socket interrupts client.connect().
+    lifecycle.rePairWait = autoLogoutCleanup.then(() => startOpenclawClawlingGateway({
+      ...params, boundaryWarningIssued: true,
+      account: { ...account, configured: false, token: "" },
+      revokedRefreshMarker: marker, refreshTokenOverride: undefined,
+      refreshManagerState: undefined, rejectedActivationToken: undefined,
+      refreshReconnectDepth: undefined, refreshReconnectWindowStartedAt: undefined,
+    }));
+    return autoLogoutCleanup;
   };
 
   // §C.1.4 — surface the permanent-expiry message to the user/operator. The
@@ -1491,7 +1591,7 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
     (activationAccount.source === "sqlite" && store?.getActivationCredentials
       ? store.getActivationCredentials({ platform: "openclaw", accountId })?.refreshToken
       : null) ??
-    readConfigRefreshToken(cfg, accountId);
+    readConfigRefreshToken(cfg, accountId, revokedRefreshMarker);
 
   const refreshManager = new RefreshManager({
     baseUrl: account.baseUrl,
@@ -1551,7 +1651,9 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
       // No SQLite store available — channel config is the only durable
       // store, so its write failure must reject and keep the refresh
       // transient (pre-existing behavior for store-less test transports).
-      await persistConfigTokens(tokens);
+      if (!await persistConfigTokens(tokens)) {
+        throw new Error("clawchat-plugin-openclaw config persistence unavailable");
+      }
     },
     swapInMemoryTokens: (tokens) => {
       account = { ...account, token: tokens.accessToken, configured: true };
@@ -1830,7 +1932,8 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
     const startupOutcome = await refreshManager.refresh("startup-near-expiry");
     if (abortSignal.aborted) return;
     if (startupOutcome.kind === "permanent") {
-      // Auto-logout already performed by the manager's onPermanentFailure.
+      // Wait for re-pair or abort rather than settling the host channel task.
+      await lifecycle.rePairWait;
       return;
     }
     // success swaps the in-memory token in place; transient/skipped just connect
@@ -1878,6 +1981,7 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
       },
     },
   });
+  refreshClient = client;
   log?.info?.(`[${accountId}] clawchat-plugin-openclaw runtime client created`);
 
   // §A.3/§A.4 — recompute the refresh-driven reconnect streak (depth + window).
@@ -2018,7 +2122,10 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
     }
     const outcome = await refreshManager.refresh(reason);
     if (abortSignal.aborted) return "fallthrough";
-    if (autoLoggedOut) return "handled"; // permanent → manager auto-logged-out.
+    if (autoLoggedOut) {
+      await lifecycle.rePairWait;
+      return "handled";
+    }
     if (outcome.kind === "success") {
       await closeAndReconnectWithRefreshedToken(reason);
       return "handled";
@@ -3443,7 +3550,24 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
     return "claimed";
   };
 
-  const dispatchTurnToAgent = async (turn: IngestTurnParams): Promise<IngestTurnResult> => {
+  // The group's title from its metadata file, which the turn's profile sync
+  // has just refreshed (so a group's first command already has it); the
+  // group id when none is on record.
+  const groupTitleForReceipt = async (groupId: string, memoryRoot: string): Promise<string> => {
+    try {
+      const file = await readClawChatMemoryFile(memoryRoot, { targetType: "group", targetId: groupId });
+      const title = file.exists ? file.metadata.group_title : undefined;
+      if (typeof title === "string" && title.trim()) return title.trim();
+    } catch {
+      // Fall back to the id below.
+    }
+    return groupId;
+  };
+
+  const dispatchTurnToAgent = async (
+    turn: IngestTurnParams,
+    options: { ownerGroupCommand?: string } = {},
+  ): Promise<IngestTurnResult> => {
     const rt = runtime.channel;
     const routeCfg = withClawChatSessionScope(cfg);
     const route = rt.routing.resolveAgentRoute({
@@ -3475,6 +3599,15 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
       );
     }
     turn = await withCachedGroupSenderNames(turn, memoryRoot);
+    const ownerCommandReceipt = options.ownerGroupCommand && turn.peer.kind === "group"
+      ? {
+          header: ownerCommandReceiptHeader(
+            await groupTitleForReceipt(turn.peer.id, memoryRoot),
+            options.ownerGroupCommand,
+          ),
+          commandMessageId: turn.messageId,
+        }
+      : undefined;
     const conversationTarget = `${CHANNEL_ID}:${formatConversationSubject(turn.peer)}`;
     const senderIsOwner = turn.senderIsOwner === true || turn.senderId === account.ownerUserId;
     // Owner turn <=> the owner's activation direct chat. Resolved per turn;
@@ -3669,6 +3802,7 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
           // member-backend). Passed as a thunk so it is resolved at send time.
           resolveOwnerConversationId: resolveOwnerDirectConversationId,
           nonOwnerTurn: turnClass === "non-owner",
+          ...(ownerCommandReceipt ? { ownerCommandReceipt } : {}),
           log,
         });
 
@@ -3758,8 +3892,9 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
       // return on abort, but only AFTER it has already taken the idempotency claim
       // (`claimInboundTurn` runs BEFORE the gate wait there, so the frame is durably
       // persisted before the interruptible wait — required by legacy advance-on-
-      // write delivery, where a frame written before a disconnect is not re-delivered
-      // on reconnect; see docs/client-integration.md §11.7). So even an ingest-time
+      // write delivery, where a frame written before a disconnect is not reliably
+      // re-delivered on reconnect (legacy may lose OR replay; a replay is deduped by
+      // the claim); see docs/client-integration.md §11.7). So even an ingest-time
       // abort keeps the frame; it just skips dispatch. Here at FLUSH the batch was
       // likewise already claimed at ingest AND `flush()` has already removed it from
       // the coalescer's pending set. An abort early-return would therefore silently
@@ -3883,7 +4018,7 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
     const senderBatchIdentity = rawTurn.peer.kind === "group"
       ? resolveSenderBatchIdentityForTurn(rawTurn)
       : {};
-    const turn: IngestTurnParams = {
+    let turn: IngestTurnParams = {
       ...rawTurn,
       senderNickName: resolveSenderNickNameForTurn(rawTurn),
       ...senderBatchIdentity,
@@ -3895,11 +4030,14 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
       // can interrupt. This client does NOT advertise `reliable_delivery`
       // (src/ws-client.ts), so under legacy delivery the server's replay cursor
       // advances on socket-WRITE (docs/client-integration.md §11.7): a frame
-      // already written before a disconnect is NOT re-delivered on reconnect.
+      // already written before a disconnect is NOT reliably re-delivered on
+      // reconnect. Legacy is not at-most-once either — a multi-replica server
+      // (relayed frames do not advance the cursor) or a failed cursor write can
+      // replay frames already received — and the claim below dedupes those.
       // `claimMessageOnce` is the ONLY durability an inbound has, and the store
       // never reprocesses undispatched inbounds. So if we claimed only AFTER the
-      // wait, a shutdown-mid-wait would leave the frame neither persisted NOR
-      // replayed — permanently lost. Claiming first makes it durable; the abort
+      // wait, a shutdown-mid-wait would leave the frame unpersisted with no
+      // guaranteed replay — lost. Claiming first makes it durable; the abort
       // check below then returns without dispatching, but the frame is kept.
       // `claimInboundTurn` is INSERT OR IGNORE, so a genuine duplicate (same
       // message_id) is still deduped here exactly once. The claim fails CLOSED:
@@ -3934,7 +4072,14 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
         );
         return "stored_muted";
       }
-      if (isKnownOpenClawGroupSlashCommand(turn.rawBody, cfg)) {
+      // `@agent /cmd` counts as `/cmd` once the leading mentions are off.
+      const commandText = isKnownOpenClawGroupSlashCommand(turn.rawBody, cfg)
+        ? turn.rawBody
+        : turn.addressedCommandBody && isKnownOpenClawGroupSlashCommand(turn.addressedCommandBody, cfg)
+          ? turn.addressedCommandBody
+          : null;
+      if (commandText) {
+        turn = { ...turn, rawBody: commandText };
         if (isOpenClawConfirmSlashCommand(turn.rawBody)) {
           return forwardGroupApprovalSlashToOwner(turn);
         }
@@ -3947,10 +4092,13 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
           );
           return "skipped";
         }
+        // The owner's command answers in the owner's direct chat; a command
+        // that starts an agent turn, or anyone else's, answers in the group.
+        const receiptToOwner = turn.senderIsOwner === true && !opensAgentTurn(commandText);
         log?.info?.(
-          `[${accountId}] clawchat-plugin-openclaw dispatching group command chat_id=${turn.peer.id} msg=${turn.messageId} mode=${commandMode}`,
+          `[${accountId}] clawchat-plugin-openclaw dispatching group command chat_id=${turn.peer.id} msg=${turn.messageId} mode=${commandMode} receipt=${receiptToOwner ? "owner" : "group"}`,
         );
-        return dispatchTurnToAgent(turn);
+        return dispatchTurnToAgent(turn, receiptToOwner ? { ownerGroupCommand: commandText } : {});
       }
       if (eff.replyMode === "mention" && !turn.wasMentioned) {
         log?.info?.(
@@ -4226,6 +4374,10 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
     await client.connect();
     log?.info?.(`[${accountId}] clawchat-plugin-openclaw runtime client.connect() resolved`);
   } catch (err) {
+    if (autoLoggedOut) {
+      await lifecycle.rePairWait;
+      return;
+    }
     const classified = classifyClawlingClientError(err);
     if (classified.kind === "auth") {
       // §A.2/§B — initial-connect hello-fail(auth). Do NOT pre-flip
@@ -4301,6 +4453,10 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
     );
     return;
   }
+  if (autoLoggedOut) {
+    await lifecycle.rePairWait;
+    return;
+  }
   activeClients.set(accountId, client);
   // Text "@name" autolinking on outbound group sends reads the same cached
   // roster (participant ids + nicknames) the group prompt shows the model.

package/src/storage.ts

@@ -1,3 +1,4 @@
+import type { RevokedRefreshMarker } from "./refresh-manager.ts";
 import fs from "node:fs";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
@@ -427,6 +428,19 @@ CREATE INDEX IF NOT EXISTS idx_clawchat_messages_protocol_message_id_nocase
     sql: `
 CREATE INDEX IF NOT EXISTS idx_clawchat_messages_chat_id_nocase
   ON clawchat_messages(chat_id COLLATE NOCASE);
+`,
+  },
+  {
+    version: 13,
+    name: "revoked_refresh_tokens",
+    sql: `
+CREATE TABLE IF NOT EXISTS revoked_refresh_tokens (
+  platform TEXT NOT NULL,
+  account_id TEXT NOT NULL,
+  fingerprint TEXT NOT NULL,
+  revoked_at INTEGER NOT NULL,
+  PRIMARY KEY (platform, account_id)
+);
 `,
   },
 ];
@@ -600,6 +614,34 @@ export class ClawChatStore {
     });
   }
 
+  setRevokedRefreshMarker(input: ClearActivationCredentialsInput & RevokedRefreshMarker): boolean | null {
+    return this.write(() => {
+      this.requireDb().prepare(`INSERT INTO revoked_refresh_tokens
+        (platform, account_id, fingerprint, revoked_at) VALUES (?, ?, ?, ?)
+        ON CONFLICT(platform, account_id) DO UPDATE SET
+        fingerprint = excluded.fingerprint, revoked_at = excluded.revoked_at`)
+        .run(input.platform, input.accountId, input.fingerprint, input.revokedAt);
+      return true;
+    });
+  }
+
+  getRevokedRefreshMarker(input: ClearActivationCredentialsInput): RevokedRefreshMarker | null {
+    return this.read(() => {
+      const row = this.requireDb().prepare(`SELECT fingerprint, revoked_at AS revokedAt
+        FROM revoked_refresh_tokens WHERE platform = ? AND account_id = ?`)
+        .get(input.platform, input.accountId) as RevokedRefreshMarker | undefined;
+      return row ?? null;
+    }) ?? null;
+  }
+
+  clearRevokedRefreshMarker(input: ClearActivationCredentialsInput): boolean | null {
+    return this.write(() => {
+      this.requireDb().prepare(`DELETE FROM revoked_refresh_tokens WHERE platform = ? AND account_id = ?`)
+        .run(input.platform, input.accountId);
+      return true;
+    });
+  }
+
   getActivationCredentials(input: ConversationAccountInput): ActivationCredentials | null {
     return this.read(() => {
       const row = this.requireDb()