@clawling/clawchat-plugin-openclaw 2026.6.30-2 → 2026.6.30-4

package/dist/src/reply-dispatcher.js

@@ -296,6 +296,12 @@ export function createOpenclawClawlingReplyDispatcher(options) {
     let typingActive = false;
     let terminalReplySuppressed = false;
     let finalDeliverySeen = false;
+    // Count of outbound messages that were actually delivered to the target
+    // (a real, successful send — not a suppressed/duplicate/failed one). This is
+    // the reliable "did anything actually reach the user?" signal; host-side
+    // `counts.block`/`counts.final` only reflect what the agent emitted, not
+    // whether the send succeeded (a cancelled send still counts as a block).
+    let outboundDeliveredCount = 0;
     const outboundEventType = () => (replyCtx ? "message.reply" : "message.send");
     const outboundRaw = () => ({ target, replyCtx: replyCtx ?? null });
     const terminalSendScopeId = options.terminalSendScopeId ?? null;
@@ -502,6 +508,8 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             log,
         });
         recordOutboundAck("message", messageId, result);
+        if (result)
+            outboundDeliveredCount += 1;
         log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw send complete to=${target.chatId}`);
         openclawLlmContextDebug.writeSnapshot({
             visibility: "host_event",
@@ -676,6 +684,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
     });
     return {
         dispatcher: base.dispatcher,
+        getOutboundDeliveredCount: () => outboundDeliveredCount,
         replyOptions: {
             ...base.replyOptions,
             sourceReplyDeliveryMode: "automatic",

package/dist/src/runtime.js

@@ -33,6 +33,34 @@ export { setOpenclawClawlingRuntime, getOpenclawClawlingRuntime };
 const activeClients = new Map();
 const CLAWCHAT_PLUGIN_SLASH_COMMANDS = new Set(["clawchat-activate", "clawchat-output"]);
 const ACTIVATION_CREDENTIAL_POLL_INTERVAL_MS = 2_000;
+// Activation-bootstrap retry on the live connection. The bootstrap greeting is
+// otherwise only (re)dispatched on a fresh `connected` edge, so if its send is
+// cancelled mid-turn (e.g. a proactive token-refresh reconnect closed the
+// transport) or a reconnect's claim no-op'd while a stale in-flight dispatch
+// still held the claim, the greeting would stay pending forever on a now-stable
+// connection. These bound an in-connection retry that re-attempts until the
+// greeting lands or the per-connection budget is spent (then it falls back to
+// the next reconnect, as before).
+const ACTIVATION_BOOTSTRAP_RETRY_DELAY_MS = 5_000;
+const ACTIVATION_BOOTSTRAP_MAX_RETRIES = 6;
+// Count of in-flight activation-bootstrap dispatches per account, shared across
+// gateway re-enters so a fresh connection can tell "nothing pending" (don't
+// retry) apart from "a prior dispatch still holds the claim" (retry once it
+// releases).
+const activationBootstrapInFlight = new Map();
+function incrementActivationBootstrapInFlight(accountId) {
+    activationBootstrapInFlight.set(accountId, (activationBootstrapInFlight.get(accountId) ?? 0) + 1);
+}
+function decrementActivationBootstrapInFlight(accountId) {
+    const next = (activationBootstrapInFlight.get(accountId) ?? 0) - 1;
+    if (next <= 0)
+        activationBootstrapInFlight.delete(accountId);
+    else
+        activationBootstrapInFlight.set(accountId, next);
+}
+function activationBootstrapInFlightCount(accountId) {
+    return activationBootstrapInFlight.get(accountId) ?? 0;
+}
 // Upper bound (ms) on how long group ingest waits for the FIRST group-settings
 // pull to settle before proceeding anyway. Best-effort governance must never
 // permanently disable group traffic, so a stalled initial GET (endpoint accepts
@@ -1446,10 +1474,38 @@ export async function startOpenclawClawlingGateway(params) {
     };
     let dispatchActivationBootstrap = async () => { };
     // Set by dispatchTurnToAgent when it dispatches the synthetic
-    // `clawchat-bootstrap` turn: true only if the agent actually produced a final
-    // outbound message (the greeting). The bootstrap dispatcher reads it to decide
-    // whether to mark the bootstrap sent or leave it pending for a later retry.
-    let bootstrapProducedFinal = false;
+    // `clawchat-bootstrap` turn: true only if the greeting was actually delivered
+    // (a real successful outbound send — block or final). The bootstrap dispatcher
+    // reads it to decide whether to mark the bootstrap sent or leave it pending for
+    // a later retry.
+    let bootstrapGreetingDelivered = false;
+    // Per-connection retry for a pending activation bootstrap (see the module-level
+    // constants). Re-attempts on the live connection while `wsReady`, bounded by
+    // ACTIVATION_BOOTSTRAP_MAX_RETRIES; the budget resets on each fresh connect.
+    let bootstrapRetryTimer;
+    let bootstrapRetryAttempts = 0;
+    const bootstrapRetryDelayMs = Math.max(1, params.activationBootstrapRetryDelayMs ?? ACTIVATION_BOOTSTRAP_RETRY_DELAY_MS);
+    const clearBootstrapRetry = () => {
+        if (bootstrapRetryTimer !== undefined) {
+            clearTimeout(bootstrapRetryTimer);
+            bootstrapRetryTimer = undefined;
+        }
+    };
+    const armBootstrapRetry = () => {
+        if (bootstrapRetryTimer !== undefined)
+            return;
+        if (!wsReady)
+            return;
+        if (bootstrapRetryAttempts >= ACTIVATION_BOOTSTRAP_MAX_RETRIES)
+            return;
+        bootstrapRetryTimer = setTimeout(() => {
+            bootstrapRetryTimer = undefined;
+            if (!wsReady)
+                return;
+            bootstrapRetryAttempts += 1;
+            void dispatchActivationBootstrap();
+        }, bootstrapRetryDelayMs);
+    };
     client.on("state", ({ from, to }) => {
         log?.info?.(`[${accountId}] clawchat-plugin-openclaw state ${from} -> ${to}`);
         wsReady = to === "connected";
@@ -1522,6 +1578,9 @@ export async function startOpenclawClawlingGateway(params) {
                 // The queue keeps the failed frame at the head and will retry after the next reconnect.
             }
             void refreshConversationCacheAfterReady();
+            // Fresh connection → fresh retry budget; cancel any stale timer first.
+            bootstrapRetryAttempts = 0;
+            clearBootstrapRetry();
             void dispatchActivationBootstrap();
             // Re-pull per-group agent settings on every successful (re)connect so the
             // cache stays current after a network interruption or token refresh.
@@ -1533,6 +1592,8 @@ export async function startOpenclawClawlingGateway(params) {
         }
         else if (to === "disconnected") {
             reconnectTracker.markClosed();
+            // Stop the bootstrap retry while down; it re-arms on the next ready.
+            clearBootstrapRetry();
             // §A.1 — clear the proactive timer on disconnect; it re-arms on the next
             // ready, or the gateway re-enter arms a fresh one.
             if (!reconnectWithRefreshedToken)
@@ -2106,7 +2167,7 @@ export async function startOpenclawClawlingGateway(params) {
                 chatType: turn.peer.kind,
                 agentId: route.agentId,
             });
-            const { dispatcher, replyOptions, markDispatchIdle } = createOpenclawClawlingReplyDispatcher({
+            const { dispatcher, replyOptions, markDispatchIdle, getOutboundDeliveredCount } = createOpenclawClawlingReplyDispatcher({
                 cfg,
                 runtime,
                 account,
@@ -2142,10 +2203,14 @@ export async function startOpenclawClawlingGateway(params) {
                 const counts = dispatchResult?.counts ?? {};
                 const queuedFinal = Boolean(dispatchResult?.queuedFinal);
                 if (turn.senderId === "clawchat-bootstrap") {
-                    // Did the agent actually emit a greeting? A final outbound message
-                    // means yes; block/tool-only (or nothing) means the greeting never
-                    // reached the user, so the bootstrap dispatcher will keep it pending.
-                    bootstrapProducedFinal = queuedFinal || (counts.final ?? 0) > 0;
+                    // Did the greeting actually reach the user? The reliable signal is a
+                    // real, successful outbound send (the agent may deliver the greeting
+                    // as a `block`, not a `final`, and a cancelled send still shows up in
+                    // host `counts.block`). Treat a queued/counted final as delivered too,
+                    // to cover deferred/human-delay finals not yet flushed at this point.
+                    const deliveredOutbound = getOutboundDeliveredCount?.() ?? 0;
+                    bootstrapGreetingDelivered =
+                        deliveredOutbound > 0 || queuedFinal || (counts.final ?? 0) > 0;
                 }
                 log?.info?.(`[${accountId}] clawchat-plugin-openclaw dispatch complete msg=${turn.messageId} queuedFinal=${queuedFinal} counts=${JSON.stringify(counts)}`);
                 if (!queuedFinal && Object.values(counts).every((n) => !n)) {
@@ -2389,6 +2454,7 @@ export async function startOpenclawClawlingGateway(params) {
         if (!store?.claimPendingActivationBootstrap || !store.markActivationBootstrapSent)
             return;
         let bootstrap;
+        let claimedInFlight = false;
         const releaseBootstrap = () => {
             if (!bootstrap || !store.releaseActivationBootstrapClaim)
                 return;
@@ -2401,23 +2467,34 @@ export async function startOpenclawClawlingGateway(params) {
         };
         try {
             bootstrap = recordConnection("activation bootstrap claim", () => store.claimPendingActivationBootstrap?.({ platform: "openclaw", accountId }));
-            if (!bootstrap)
+            if (!bootstrap) {
+                // Nothing claimable right now. If another dispatch (e.g. a pre-reconnect
+                // one that was about to fail) still holds the claim, keep retrying on
+                // this live connection so the greeting isn't stranded once it releases.
+                if (activationBootstrapInFlightCount(accountId) > 0)
+                    armBootstrapRetry();
                 return;
+            }
             const claimedBootstrap = bootstrap;
-            bootstrapProducedFinal = false;
+            claimedInFlight = true;
+            incrementActivationBootstrapInFlight(accountId);
+            bootstrapGreetingDelivered = false;
             const result = await handleInboundEnvelope(buildActivationBootstrapEnvelope({ account, conversationId: claimedBootstrap.conversationId }));
             if (result !== "submitted") {
                 releaseBootstrap();
+                armBootstrapRetry();
                 return;
             }
-            // Only mark the bootstrap done once the agent has actually sent a greeting
-            // (a final outbound message). If the turn was handed off but produced no
-            // final reply — e.g. the agent went off to write a file/note instead of
-            // replying — leave the bootstrap pending (release the claim) so the next
-            // ready re-dispatches it, rather than silently consuming it forever.
-            if (!bootstrapProducedFinal) {
-                log?.info?.(`[${accountId}] clawchat-plugin-openclaw activation bootstrap dispatched but produced no final reply; leaving pending for retry`);
+            // Only mark the bootstrap done once the greeting was actually delivered
+            // (a real successful outbound send). If the turn was handed off but nothing
+            // reached the user — e.g. the greeting send was cancelled by a reconnect, or
+            // the agent went off to write a file/note instead of replying — leave the
+            // bootstrap pending (release the claim) and retry on the live connection,
+            // rather than silently consuming it forever or waiting for the next reconnect.
+            if (!bootstrapGreetingDelivered) {
+                log?.info?.(`[${accountId}] clawchat-plugin-openclaw activation bootstrap dispatched but greeting was not delivered; leaving pending for retry`);
                 releaseBootstrap();
+                armBootstrapRetry();
                 return;
             }
             recordConnection("activation bootstrap sent", () => store.markActivationBootstrapSent?.({
@@ -2425,11 +2502,18 @@ export async function startOpenclawClawlingGateway(params) {
                 accountId,
                 conversationId: claimedBootstrap.conversationId,
             }));
+            // Delivered — stop any pending retry.
+            clearBootstrapRetry();
         }
         catch (err) {
             releaseBootstrap();
+            armBootstrapRetry();
             log?.error?.(`[${accountId}] clawchat-plugin-openclaw activation bootstrap failed: ${err instanceof Error ? err.message : String(err)}`);
         }
+        finally {
+            if (claimedInFlight)
+                decrementActivationBootstrapInFlight(accountId);
+        }
     };
     client.on("message", (env) => {
         void (async () => {
@@ -2541,6 +2625,7 @@ export async function startOpenclawClawlingGateway(params) {
         log?.info?.(`[${accountId}] clawchat-plugin-openclaw runtime abort received; closing client`);
         activeClients.delete(accountId);
         closingForAbort = true;
+        clearBootstrapRetry();
         // §A.1 — stop the proactive refresh timer on shutdown.
         refreshManager.stop();
         groupCoalescer.cancelAll();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawling/clawchat-plugin-openclaw",
-  "version": "2026.6.30-2",
+  "version": "2026.6.30-4",
   "description": "OpenClaw ClawChat channel plugin",
   "license": "MIT",
   "author": "CLAWLING PTE. LTD.",

package/src/reply-dispatcher.ts

@@ -375,6 +375,8 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
   dispatcher: TypedReplyDispatcherResult["dispatcher"];
   replyOptions: ClawChatReplyOptions;
   markDispatchIdle: TypedReplyDispatcherResult["markDispatchIdle"];
+  /** Number of outbound messages actually delivered to the target so far. */
+  getOutboundDeliveredCount: () => number;
 } {
   const {
     cfg,
@@ -430,6 +432,12 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
   let typingActive = false;
   let terminalReplySuppressed = false;
   let finalDeliverySeen = false;
+  // Count of outbound messages that were actually delivered to the target
+  // (a real, successful send — not a suppressed/duplicate/failed one). This is
+  // the reliable "did anything actually reach the user?" signal; host-side
+  // `counts.block`/`counts.final` only reflect what the agent emitted, not
+  // whether the send succeeded (a cancelled send still counts as a block).
+  let outboundDeliveredCount = 0;
 
   const outboundEventType = () => (replyCtx ? "message.reply" : "message.send");
   const outboundRaw = () => ({ target, replyCtx: replyCtx ?? null });
@@ -646,6 +654,7 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
       log,
     });
     recordOutboundAck("message", messageId, result);
+    if (result) outboundDeliveredCount += 1;
     log?.info?.(
       `[${account.accountId}] clawchat-plugin-openclaw send complete to=${target.chatId}`,
     );
@@ -835,6 +844,7 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
 
   return {
     dispatcher: base.dispatcher,
+    getOutboundDeliveredCount: () => outboundDeliveredCount,
     replyOptions: {
       ...base.replyOptions,
       sourceReplyDeliveryMode: "automatic",

package/src/runtime.ts

@@ -120,6 +120,32 @@ export { setOpenclawClawlingRuntime, getOpenclawClawlingRuntime };
 const activeClients = new Map<string, ClawlingChatClient>();
 const CLAWCHAT_PLUGIN_SLASH_COMMANDS = new Set(["clawchat-activate", "clawchat-output"]);
 const ACTIVATION_CREDENTIAL_POLL_INTERVAL_MS = 2_000;
+// Activation-bootstrap retry on the live connection. The bootstrap greeting is
+// otherwise only (re)dispatched on a fresh `connected` edge, so if its send is
+// cancelled mid-turn (e.g. a proactive token-refresh reconnect closed the
+// transport) or a reconnect's claim no-op'd while a stale in-flight dispatch
+// still held the claim, the greeting would stay pending forever on a now-stable
+// connection. These bound an in-connection retry that re-attempts until the
+// greeting lands or the per-connection budget is spent (then it falls back to
+// the next reconnect, as before).
+const ACTIVATION_BOOTSTRAP_RETRY_DELAY_MS = 5_000;
+const ACTIVATION_BOOTSTRAP_MAX_RETRIES = 6;
+// Count of in-flight activation-bootstrap dispatches per account, shared across
+// gateway re-enters so a fresh connection can tell "nothing pending" (don't
+// retry) apart from "a prior dispatch still holds the claim" (retry once it
+// releases).
+const activationBootstrapInFlight = new Map<string, number>();
+function incrementActivationBootstrapInFlight(accountId: string): void {
+  activationBootstrapInFlight.set(accountId, (activationBootstrapInFlight.get(accountId) ?? 0) + 1);
+}
+function decrementActivationBootstrapInFlight(accountId: string): void {
+  const next = (activationBootstrapInFlight.get(accountId) ?? 0) - 1;
+  if (next <= 0) activationBootstrapInFlight.delete(accountId);
+  else activationBootstrapInFlight.set(accountId, next);
+}
+function activationBootstrapInFlightCount(accountId: string): number {
+  return activationBootstrapInFlight.get(accountId) ?? 0;
+}
 // Upper bound (ms) on how long group ingest waits for the FIRST group-settings
 // pull to settle before proceeding anyway. Best-effort governance must never
 // permanently disable group traffic, so a stalled initial GET (endpoint accepts
@@ -543,6 +569,8 @@ export interface StartGatewayParams {
   backoffTimer?: (cb: () => void, ms: number) => void;
   /** Test hook only — fixed transport-backoff delay (ms) for re-enter. */
   transportBackoffDelayMs?: number;
+  /** Test hook only — retry delay (ms) for re-dispatching a pending activation bootstrap. */
+  activationBootstrapRetryDelayMs?: number;
 }
 
 /**
@@ -1822,10 +1850,37 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
   };
   let dispatchActivationBootstrap: () => Promise<void> = async () => {};
   // Set by dispatchTurnToAgent when it dispatches the synthetic
-  // `clawchat-bootstrap` turn: true only if the agent actually produced a final
-  // outbound message (the greeting). The bootstrap dispatcher reads it to decide
-  // whether to mark the bootstrap sent or leave it pending for a later retry.
-  let bootstrapProducedFinal = false;
+  // `clawchat-bootstrap` turn: true only if the greeting was actually delivered
+  // (a real successful outbound send — block or final). The bootstrap dispatcher
+  // reads it to decide whether to mark the bootstrap sent or leave it pending for
+  // a later retry.
+  let bootstrapGreetingDelivered = false;
+  // Per-connection retry for a pending activation bootstrap (see the module-level
+  // constants). Re-attempts on the live connection while `wsReady`, bounded by
+  // ACTIVATION_BOOTSTRAP_MAX_RETRIES; the budget resets on each fresh connect.
+  let bootstrapRetryTimer: ReturnType<typeof setTimeout> | undefined;
+  let bootstrapRetryAttempts = 0;
+  const bootstrapRetryDelayMs = Math.max(
+    1,
+    params.activationBootstrapRetryDelayMs ?? ACTIVATION_BOOTSTRAP_RETRY_DELAY_MS,
+  );
+  const clearBootstrapRetry = () => {
+    if (bootstrapRetryTimer !== undefined) {
+      clearTimeout(bootstrapRetryTimer);
+      bootstrapRetryTimer = undefined;
+    }
+  };
+  const armBootstrapRetry = () => {
+    if (bootstrapRetryTimer !== undefined) return;
+    if (!wsReady) return;
+    if (bootstrapRetryAttempts >= ACTIVATION_BOOTSTRAP_MAX_RETRIES) return;
+    bootstrapRetryTimer = setTimeout(() => {
+      bootstrapRetryTimer = undefined;
+      if (!wsReady) return;
+      bootstrapRetryAttempts += 1;
+      void dispatchActivationBootstrap();
+    }, bootstrapRetryDelayMs);
+  };
 
   client.on("state", ({ from, to }) => {
     log?.info?.(`[${accountId}] clawchat-plugin-openclaw state ${from} -> ${to}`);
@@ -1900,6 +1955,9 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
         // The queue keeps the failed frame at the head and will retry after the next reconnect.
       }
       void refreshConversationCacheAfterReady();
+      // Fresh connection → fresh retry budget; cancel any stale timer first.
+      bootstrapRetryAttempts = 0;
+      clearBootstrapRetry();
       void dispatchActivationBootstrap();
       // Re-pull per-group agent settings on every successful (re)connect so the
       // cache stays current after a network interruption or token refresh.
@@ -1910,6 +1968,8 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
       refreshManager.armProactiveTimer(activatedAtMs);
     } else if (to === "disconnected") {
       reconnectTracker.markClosed();
+      // Stop the bootstrap retry while down; it re-arms on the next ready.
+      clearBootstrapRetry();
       // §A.1 — clear the proactive timer on disconnect; it re-arms on the next
       // ready, or the gateway re-enter arms a fresh one.
       if (!reconnectWithRefreshedToken) refreshManager.disarmProactiveTimer();
@@ -2544,7 +2604,7 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
         chatType: turn.peer.kind,
         agentId: route.agentId,
       });
-      const { dispatcher, replyOptions, markDispatchIdle } =
+      const { dispatcher, replyOptions, markDispatchIdle, getOutboundDeliveredCount } =
         createOpenclawClawlingReplyDispatcher({
           cfg,
           runtime,
@@ -2590,10 +2650,14 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
           (dispatchResult as { queuedFinal?: boolean } | undefined)?.queuedFinal,
         );
         if (turn.senderId === "clawchat-bootstrap") {
-          // Did the agent actually emit a greeting? A final outbound message
-          // means yes; block/tool-only (or nothing) means the greeting never
-          // reached the user, so the bootstrap dispatcher will keep it pending.
-          bootstrapProducedFinal = queuedFinal || (counts.final ?? 0) > 0;
+          // Did the greeting actually reach the user? The reliable signal is a
+          // real, successful outbound send (the agent may deliver the greeting
+          // as a `block`, not a `final`, and a cancelled send still shows up in
+          // host `counts.block`). Treat a queued/counted final as delivered too,
+          // to cover deferred/human-delay finals not yet flushed at this point.
+          const deliveredOutbound = getOutboundDeliveredCount?.() ?? 0;
+          bootstrapGreetingDelivered =
+            deliveredOutbound > 0 || queuedFinal || (counts.final ?? 0) > 0;
         }
         log?.info?.(
           `[${accountId}] clawchat-plugin-openclaw dispatch complete msg=${turn.messageId} queuedFinal=${queuedFinal} counts=${JSON.stringify(counts)}`,
@@ -2876,6 +2940,7 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
   dispatchActivationBootstrap = async (): Promise<void> => {
     if (!store?.claimPendingActivationBootstrap || !store.markActivationBootstrapSent) return;
     let bootstrap: { conversationId: string } | null | undefined;
+    let claimedInFlight = false;
     const releaseBootstrap = () => {
       if (!bootstrap || !store.releaseActivationBootstrapClaim) return;
       const claimedBootstrap = bootstrap;
@@ -2891,26 +2956,37 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
       bootstrap = recordConnection("activation bootstrap claim", () =>
         store.claimPendingActivationBootstrap?.({ platform: "openclaw", accountId }),
       );
-      if (!bootstrap) return;
+      if (!bootstrap) {
+        // Nothing claimable right now. If another dispatch (e.g. a pre-reconnect
+        // one that was about to fail) still holds the claim, keep retrying on
+        // this live connection so the greeting isn't stranded once it releases.
+        if (activationBootstrapInFlightCount(accountId) > 0) armBootstrapRetry();
+        return;
+      }
       const claimedBootstrap = bootstrap;
-      bootstrapProducedFinal = false;
+      claimedInFlight = true;
+      incrementActivationBootstrapInFlight(accountId);
+      bootstrapGreetingDelivered = false;
       const result = await handleInboundEnvelope(
         buildActivationBootstrapEnvelope({ account, conversationId: claimedBootstrap.conversationId }),
       );
       if (result !== "submitted") {
         releaseBootstrap();
+        armBootstrapRetry();
         return;
       }
-      // Only mark the bootstrap done once the agent has actually sent a greeting
-      // (a final outbound message). If the turn was handed off but produced no
-      // final reply — e.g. the agent went off to write a file/note instead of
-      // replying — leave the bootstrap pending (release the claim) so the next
-      // ready re-dispatches it, rather than silently consuming it forever.
-      if (!bootstrapProducedFinal) {
+      // Only mark the bootstrap done once the greeting was actually delivered
+      // (a real successful outbound send). If the turn was handed off but nothing
+      // reached the user — e.g. the greeting send was cancelled by a reconnect, or
+      // the agent went off to write a file/note instead of replying — leave the
+      // bootstrap pending (release the claim) and retry on the live connection,
+      // rather than silently consuming it forever or waiting for the next reconnect.
+      if (!bootstrapGreetingDelivered) {
         log?.info?.(
-          `[${accountId}] clawchat-plugin-openclaw activation bootstrap dispatched but produced no final reply; leaving pending for retry`,
+          `[${accountId}] clawchat-plugin-openclaw activation bootstrap dispatched but greeting was not delivered; leaving pending for retry`,
         );
         releaseBootstrap();
+        armBootstrapRetry();
         return;
       }
       recordConnection("activation bootstrap sent", () =>
@@ -2920,11 +2996,16 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
           conversationId: claimedBootstrap.conversationId,
         }),
       );
+      // Delivered — stop any pending retry.
+      clearBootstrapRetry();
     } catch (err) {
       releaseBootstrap();
+      armBootstrapRetry();
       log?.error?.(
         `[${accountId}] clawchat-plugin-openclaw activation bootstrap failed: ${err instanceof Error ? err.message : String(err)}`,
       );
+    } finally {
+      if (claimedInFlight) decrementActivationBootstrapInFlight(accountId);
     }
   };
 
@@ -3049,6 +3130,7 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
     log?.info?.(`[${accountId}] clawchat-plugin-openclaw runtime abort received; closing client`);
     activeClients.delete(accountId);
     closingForAbort = true;
+    clearBootstrapRetry();
     // §A.1 — stop the proactive refresh timer on shutdown.
     refreshManager.stop();
     groupCoalescer.cancelAll();