@clawling/clawchat-plugin-openclaw 2026.6.30-3 → 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

@@ -1474,10 +1474,11 @@ 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.
@@ -2166,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,
@@ -2202,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)) {
@@ -2473,21 +2478,21 @@ export async function startOpenclawClawlingGateway(params) {
             const claimedBootstrap = bootstrap;
             claimedInFlight = true;
             incrementActivationBootstrapInFlight(accountId);
-            bootstrapProducedFinal = false;
+            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 greeting send was cancelled by a reconnect, or the
-            // agent went off to write a file/note instead of replying — leave the
+            // 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 (!bootstrapProducedFinal) {
-                log?.info?.(`[${accountId}] clawchat-plugin-openclaw activation bootstrap dispatched but produced no final reply; leaving pending for retry`);
+            if (!bootstrapGreetingDelivered) {
+                log?.info?.(`[${accountId}] clawchat-plugin-openclaw activation bootstrap dispatched but greeting was not delivered; leaving pending for retry`);
                 releaseBootstrap();
                 armBootstrapRetry();
                 return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawling/clawchat-plugin-openclaw",
-  "version": "2026.6.30-3",
+  "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

@@ -1850,10 +1850,11 @@ 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.
@@ -2603,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,
@@ -2649,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)}`,
@@ -2961,7 +2966,7 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
       const claimedBootstrap = bootstrap;
       claimedInFlight = true;
       incrementActivationBootstrapInFlight(accountId);
-      bootstrapProducedFinal = false;
+      bootstrapGreetingDelivered = false;
       const result = await handleInboundEnvelope(
         buildActivationBootstrapEnvelope({ account, conversationId: claimedBootstrap.conversationId }),
       );
@@ -2970,15 +2975,15 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
         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 greeting send was cancelled by a reconnect, or the
-      // agent went off to write a file/note instead of replying — leave the
+      // 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 (!bootstrapProducedFinal) {
+      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();