@velanir/openclaw-participation-gate 0.1.1 → 0.1.3

package/README.md

@@ -8,9 +8,9 @@ The plugin is designed for the `requireMention: false` use case: the coworker ca
 
 - Package: `@velanir/openclaw-participation-gate`
 - OpenClaw plugin id: `velanir-participation-gate`
-- Runtime hooks: `before_dispatch`, `message_sent`
+- Runtime hooks: `before_dispatch`, `message_sent`, `reply_payload_sending`
 - Default mode: `shadow`
-- Target OpenClaw plugin API: `>=2026.5.4`
+- Target OpenClaw plugin API: `>=2026.6.6`
 
 The platform monorepo owns the source package in `packages/openclaw-plugins/participation-gate`. Customer machines install the built package into their OpenClaw runtime.
 
@@ -31,8 +31,10 @@ For group and channel messages, the plugin:
 
 Explicit mentions still bypass classifier enforcement, but the inbound turn is
 recorded before bypass so later unmentioned follow-ups have context. Successful
-`message_sent` events are also recorded as coworker replies, which lets the
-classifier recognize follow-ups after this coworker already answered.
+`message_sent` events and final `reply_payload_sending` payloads are also
+recorded as coworker replies, which lets the classifier recognize follow-ups
+after this coworker already answered. Duplicate outbound hook records are
+deduped before they reach classifier context.
 
 Any missing runtime dependency, missing context, invalid classifier output, classifier timeout, or classifier error fails open and lets the coworker respond. This is deliberate because false silence is worse than an occasional extra reply while the plugin is being rolled out.
 
@@ -58,9 +60,10 @@ logs `classifier_malformed` instead of treating it as a clean `classifier_true`.
 
 Normal decision logs include the participation score, threshold, classifier
 prompt version, prompt hash, input hash, parse status, attempt count, output
-hash, and output length. Exact rendered prompt/input/raw classifier output and
-parse errors are logged only when `logging.classifierDebug` and
-`logging.includeContent` are both enabled.
+hash, output length, recent message count, and recent user/assistant role
+counts. Exact rendered prompt/input/raw classifier output and parse errors are
+logged only when `logging.classifierDebug` and `logging.includeContent` are
+both enabled.
 
 ## Context Contract
 

package/dist/index.d.ts

@@ -1,12 +1,16 @@
-import * as openclaw_plugin_sdk_plugin_entry from 'openclaw/plugin-sdk/plugin-entry';
+type OpenClawPluginApi = {
+    on: (hook: "before_dispatch" | "message_sent" | "reply_payload_sending", handler: (event: unknown, ctx: unknown) => unknown | Promise<unknown>, options?: {
+        priority?: number;
+        timeoutMs?: number;
+    }) => void;
+};
 
 declare const PLUGIN_ID = "velanir-participation-gate";
 declare const _default: {
     id: string;
     name: string;
     description: string;
-    configSchema: openclaw_plugin_sdk_plugin_entry.OpenClawPluginConfigSchema;
-    register: NonNullable<openclaw_plugin_sdk_plugin_entry.OpenClawPluginDefinition["register"]>;
-} & Pick<openclaw_plugin_sdk_plugin_entry.OpenClawPluginDefinition, "kind" | "reload" | "nodeHostCommands" | "securityAuditCollectors">;
+    register(api: OpenClawPluginApi): void;
+};
 
 export { PLUGIN_ID, _default as default };

package/dist/index.js

@@ -1,7 +1,8 @@
 // src/api.ts
-import {
-  definePluginEntry
-} from "openclaw/plugin-sdk/plugin-entry";
+import { definePluginEntry as defineOpenClawPluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+function definePluginEntry(entry) {
+  return defineOpenClawPluginEntry(entry);
+}
 
 // ../../oct8-secrets/dist/index.js
 import { createHash, randomUUID } from "crypto";
@@ -2209,40 +2210,60 @@ function messageIsThread(event, ctx) {
     event.messageThreadId || ctx.messageThreadId || event.parentSessionKey || ctx.parentSessionKey || event.threadStarterBody || threadHistoryText(event) || sessionKey.includes(":thread:") || sessionKey.includes("thread")
   );
 }
+function normalizeInboundHistoryMessage(message2) {
+  const content = typeof message2.content === "string" ? message2.content.trim() : typeof message2.body === "string" ? message2.body.trim() : "";
+  if (!content) {
+    return void 0;
+  }
+  const senderName = message2.senderName ?? message2.sender;
+  return {
+    ...message2.role ? { role: message2.role } : {},
+    ...message2.senderId ? { senderId: message2.senderId } : {},
+    ...senderName ? { senderName } : {},
+    content,
+    ...message2.timestamp !== void 0 ? { timestamp: message2.timestamp } : {}
+  };
+}
 function eventRecentMessages(event, maxMessages) {
   if (!Array.isArray(event.inboundHistory) || maxMessages <= 0) {
     return [];
   }
-  return event.inboundHistory.filter((message2) => message2.content.trim().length > 0).slice(-maxMessages);
-}
-function providerIsSlack(event, ctx) {
-  const provider = event.provider ?? ctx.provider ?? event.surface ?? ctx.surface ?? event.channel;
-  return provider?.toLowerCase() === "slack";
+  return event.inboundHistory.map(normalizeInboundHistoryMessage).filter((message2) => Boolean(message2)).slice(-maxMessages);
 }
 function mergeRecentMessages(params) {
   if (params.inboundHistory.length === 0) {
     return params.localHistory;
   }
-  if (providerIsSlack(params.event, params.ctx)) {
-    return params.inboundHistory;
-  }
   const merged = [];
   const seen = /* @__PURE__ */ new Set();
+  const messageKey = (message2) => [
+    message2.role ?? "user",
+    message2.senderId ?? "",
+    message2.senderName ?? "",
+    message2.timestamp ?? "",
+    message2.content
+  ].join("\0");
   for (const message2 of [...params.localHistory, ...params.inboundHistory]) {
-    const key = [
-      message2.role ?? "user",
-      message2.senderId ?? "",
-      message2.senderName ?? "",
-      message2.timestamp ?? "",
-      message2.content
-    ].join("\0");
+    const key = messageKey(message2);
     if (seen.has(key)) {
       continue;
     }
     seen.add(key);
     merged.push(message2);
   }
-  return merged.slice(-params.maxMessages);
+  const selectedKeys = new Set(merged.slice(-params.maxMessages).map(messageKey));
+  const localAssistantKeys = params.localHistory.filter((message2) => message2.role === "assistant").map(messageKey).filter((key, index, keys) => keys.indexOf(key) === index).slice(-params.maxMessages);
+  for (const assistantKey of localAssistantKeys) {
+    if (selectedKeys.has(assistantKey)) {
+      continue;
+    }
+    const keyToDrop = merged.map(messageKey).find((key) => selectedKeys.has(key) && !localAssistantKeys.includes(key));
+    if (keyToDrop) {
+      selectedKeys.delete(keyToDrop);
+    }
+    selectedKeys.add(assistantKey);
+  }
+  return merged.filter((message2) => selectedKeys.has(messageKey(message2)));
 }
 function buildClassifierInput(params) {
   const inboundHistory = eventRecentMessages(params.event, params.maxMessages);
@@ -2272,8 +2293,6 @@ function buildClassifierInput(params) {
       historyBody: threadHistoryBody
     } : void 0,
     recentMessages: mergeRecentMessages({
-      event: params.event,
-      ctx: params.ctx,
       inboundHistory,
       localHistory: params.recentMessages,
       maxMessages: params.maxMessages
@@ -2340,6 +2359,12 @@ async function decideParticipation(params) {
       classifierOutputLength: classifierDecision.outputLength,
       classifierParseError: classifierDecision.parseError,
       classifierRecentMessageCount: classifierInput.recentMessages.length,
+      classifierRecentUserMessageCount: classifierInput.recentMessages.filter(
+        (message2) => message2.role !== "assistant"
+      ).length,
+      classifierRecentAssistantMessageCount: classifierInput.recentMessages.filter(
+        (message2) => message2.role === "assistant"
+      ).length,
       classifierThreadContext: Boolean(classifierInput.thread?.starterBody || classifierInput.thread?.historyBody),
       classifierCurrentMessageLength: classifierInput.currentMessage.content.length,
       ...params.config.logging.classifierDebug ? {
@@ -2440,15 +2465,33 @@ function outboundKeys(event, ctx) {
   return keys.length > 0 ? keys : ["unknown"];
 }
 function publicMessages(messages, maxMessages) {
-  return messages.sort((left, right) => left.sequence - right.sequence).slice(-maxMessages).map(({ sequence: _sequence, ...message2 }) => message2);
+  return messages.sort((left, right) => left.sequence - right.sequence).slice(-maxMessages).map(({ sequence: _sequence, dedupeKey: _dedupeKey, ...message2 }) => message2);
+}
+function outboundDedupeKey(event, content) {
+  if (event.runId) {
+    return ["run", event.runId, content].join("\0");
+  }
+  if (event.sessionKey) {
+    return ["session", event.sessionKey, content].join("\0");
+  }
+  return ["message", event.messageId ?? "", event.to ?? "", content].join("\0");
 }
 function createParticipationHistoryStore() {
   const messagesByConversation = /* @__PURE__ */ new Map();
   let nextSequence = 1;
-  function recordForKeys(keys, message2, maxMessages) {
+  function recordForKeys(keys, message2, maxMessages, dedupeKey) {
+    if (dedupeKey) {
+      for (const key of keys) {
+        const current = messagesByConversation.get(key) ?? [];
+        if (current.some((entry) => entry.dedupeKey === dedupeKey)) {
+          return false;
+        }
+      }
+    }
     const stored = {
       ...message2,
-      sequence: nextSequence
+      sequence: nextSequence,
+      ...dedupeKey ? { dedupeKey } : {}
     };
     nextSequence += 1;
     for (const key of keys) {
@@ -2459,6 +2502,7 @@ function createParticipationHistoryStore() {
       }
       messagesByConversation.set(key, current);
     }
+    return true;
   }
   function recordInbound(event, ctx, maxMessages) {
     if (maxMessages <= 0 || event.isGroup !== true) {
@@ -2468,7 +2512,7 @@ function createParticipationHistoryStore() {
     if (!content) {
       return false;
     }
-    recordForKeys(
+    return recordForKeys(
       inboundKeys(event, ctx),
       {
         role: "user",
@@ -2479,7 +2523,6 @@ function createParticipationHistoryStore() {
       },
       maxMessages
     );
-    return true;
   }
   return {
     recent(event, ctx, maxMessages) {
@@ -2507,7 +2550,7 @@ function createParticipationHistoryStore() {
       if (!content) {
         return false;
       }
-      recordForKeys(
+      return recordForKeys(
         outboundKeys(event, ctx),
         {
           role: "assistant",
@@ -2515,9 +2558,9 @@ function createParticipationHistoryStore() {
           senderName: "This coworker",
           content
         },
-        maxMessages
+        maxMessages,
+        outboundDedupeKey(event, content)
       );
-      return true;
     },
     record(event, ctx, maxMessages) {
       return recordInbound(event, ctx, maxMessages);
@@ -2569,6 +2612,8 @@ function logParticipationDecision(params) {
     field("outputHash", params.decision.classifierOutputHash),
     field("outputLength", params.decision.classifierOutputLength),
     field("recentMessages", params.decision.classifierRecentMessageCount),
+    field("recentUserMessages", params.decision.classifierRecentUserMessageCount),
+    field("recentAssistantMessages", params.decision.classifierRecentAssistantMessageCount),
     field("threadContext", params.decision.classifierThreadContext),
     field("currentLength", params.decision.classifierCurrentMessageLength),
     contentLoggingEnabled(params.config) ? field("parseError", params.decision.classifierParseError) : void 0,
@@ -2590,6 +2635,8 @@ function logParticipationDecision(params) {
       outputHash: params.decision.classifierOutputHash,
       outputLength: params.decision.classifierOutputLength,
       recentMessages: params.decision.classifierRecentMessageCount,
+      recentUserMessages: params.decision.classifierRecentUserMessageCount,
+      recentAssistantMessages: params.decision.classifierRecentAssistantMessageCount,
       threadContext: params.decision.classifierThreadContext,
       currentMessageLength: params.decision.classifierCurrentMessageLength,
       outcome
@@ -2634,6 +2681,31 @@ function logParticipationHistoryEvent(params) {
 
 // src/index.ts
 var PLUGIN_ID = "velanir-participation-gate";
+function replyPayloadContent(event) {
+  const text = event.payload?.text;
+  if (typeof text !== "string") {
+    return void 0;
+  }
+  const trimmed = text.trim();
+  return trimmed || void 0;
+}
+function messageSentEventFromReplyPayload(event, ctx, content) {
+  return {
+    to: ctx.conversationId ?? ctx.channelId ?? event.channel,
+    content,
+    success: true,
+    sessionKey: event.sessionKey ?? ctx.sessionKey,
+    runId: event.runId ?? ctx.runId
+  };
+}
+function messageSentContextFromReplyPayload(event, ctx) {
+  return {
+    ...ctx,
+    ...event.channel && !ctx.channelId ? { channelId: event.channel } : {},
+    ...event.sessionKey && !ctx.sessionKey ? { sessionKey: event.sessionKey } : {},
+    ...event.runId && !ctx.runId ? { runId: event.runId } : {}
+  };
+}
 var index_default = definePluginEntry({
   id: PLUGIN_ID,
   name: "Velanir Participation Gate",
@@ -2713,6 +2785,39 @@ var index_default = definePluginEntry({
       });
       return void 0;
     });
+    api.on("reply_payload_sending", (event, ctx) => {
+      const replyEvent = event;
+      if (replyEvent.kind !== void 0 && replyEvent.kind !== "final") {
+        return void 0;
+      }
+      const content = replyPayloadContent(replyEvent);
+      if (!content) {
+        return void 0;
+      }
+      const replyContext = ctx;
+      const messageSentEvent = messageSentEventFromReplyPayload(replyEvent, replyContext, content);
+      const messageSentContext = messageSentContextFromReplyPayload(replyEvent, replyContext);
+      const recorded = history.recordOutbound(
+        messageSentEvent,
+        messageSentContext,
+        config.context.maxMessages
+      );
+      logParticipationHistoryEvent({
+        logger: runtimeApi.logger,
+        config,
+        event: "reply_payload_outbound",
+        fields: {
+          recorded,
+          kind: replyEvent.kind,
+          channel: messageSentContext.channelId,
+          conversation: messageSentContext.conversationId ?? messageSentEvent.to,
+          session: messageSentContext.sessionKey ?? messageSentEvent.sessionKey,
+          runId: messageSentEvent.runId
+        },
+        content
+      });
+      return void 0;
+    });
   }
 });
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velanir/openclaw-participation-gate",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "OpenClaw plugin that gates group/channel participation for Velanir digital coworkers.",
   "license": "UNLICENSED",
   "type": "module",
@@ -34,7 +34,7 @@
     "test": "pnpm --filter=@oct8/oct8-secrets build && vitest run"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.5.4"
+    "openclaw": ">=2026.6.6"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -44,7 +44,7 @@
   "devDependencies": {
     "@oct8/oct8-secrets": "workspace:*",
     "@types/node": "^22.19.1",
-    "openclaw": "2026.5.4",
+    "openclaw": "2026.6.6",
     "tsup": "^8.4.0",
     "typescript": "^5.7.0",
     "vitest": "^4.0.0"
@@ -57,7 +57,8 @@
       "./dist/index.js"
     ],
     "compat": {
-      "pluginApi": ">=2026.5.4"
+      "pluginApi": ">=2026.6.6",
+      "minGatewayVersion": "2026.6.6"
     }
   }
 }