@velanir/openclaw-participation-gate 0.1.3 → 0.2.0

package/README.md

@@ -8,8 +8,10 @@ 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`, `reply_payload_sending`
+- Runtime hooks: `before_dispatch`, `before_tool_call`, `message_sending`,
+  `message_sent`, `reply_payload_sending`
 - Default mode: `shadow`
+- Default delivery mode: `passthrough`
 - 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.
@@ -38,6 +40,44 @@ 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.
 
+## Turn Delivery Coalescer
+
+The `delivery` config controls what the user actually sees for one inbound
+turn. It is independent of the participation decision above.
+
+- `passthrough` (default): the plugin does not alter delivery at all. This is
+  the rollback value.
+- `coalesce`: the plugin tracks each inbound turn by its exact session key
+  (falling back to provider+conversation, then channel) and enforces
+  final-only delivery for that turn:
+  - Non-final reply payloads (`kind: "tool"` / `"block"`) are cancelled.
+  - At most `maxProgressMessages` (0 or 1) generic progress updates may
+    deliver, and only after `quietWindowMs` of silence. The progress text is
+    always the configured `progressText`; model-authored narration is never
+    exposed. `maxProgressMessages: 0` means fully silent until the final.
+  - Exactly one final reply payload is admitted per turn. Duplicate finals for
+    the same turn or the same `runId` are cancelled.
+  - A `message` tool `send` call targeting the active inbound conversation is
+    blocked before execution (`before_tool_call`), so the model cannot bypass
+    the final-reply boundary by messaging the conversation directly. Sends to
+    unrelated destinations, other providers, or from sessions with no tracked
+    inbound turn (proactive and scheduled sends) are not affected.
+  - Direct outbound egress (`message_sending`) to the active conversation is
+    allowed only when it corresponds to the final payload the coalescer
+    already admitted.
+- Turn state expires after `turnTtlMs` so an abandoned turn cannot silence a
+  conversation indefinitely.
+
+Delivery state is process-shared across plugin re-registers, so a gateway
+config reload does not reset duplicate-final protection for an in-flight turn.
+
+### Rollback
+
+Set `delivery.mode` back to `passthrough` (or remove the `delivery` block) and
+refresh the runtime config. No uninstall or version change is required; every
+delivery hook becomes a no-op. Anything other than an explicit
+`"coalesce"` value normalizes to `passthrough`.
+
 ## Classifier Contract
 
 The classifier returns a scored participation decision:
@@ -135,6 +175,12 @@ Runtime mode expects the same runtime identity environment used by `oct8-secrets
     "baseUrl": "https://api.velanir.ai",
     "coworkerId": "coworker_albus"
   },
+  "delivery": {
+    "mode": "passthrough",
+    "quietWindowMs": 45000,
+    "maxProgressMessages": 1,
+    "turnTtlMs": 600000
+  },
   "logging": {
     "decisions": true,
     "includeContent": false,

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 type OpenClawPluginApi = {
-    on: (hook: "before_dispatch" | "message_sent" | "reply_payload_sending", handler: (event: unknown, ctx: unknown) => unknown | Promise<unknown>, options?: {
+    on: (hook: "before_dispatch" | "before_tool_call" | "message_sending" | "message_sent" | "reply_payload_sending", handler: (event: unknown, ctx: unknown) => unknown | Promise<unknown>, options?: {
         priority?: number;
         timeoutMs?: number;
     }) => void;

package/dist/index.js

@@ -1625,6 +1625,10 @@ var DEFAULT_CLASSIFIER_THRESHOLD = 0.7;
 var DEFAULT_MAX_MESSAGES = 5;
 var DEFAULT_REFRESH_MS = 5 * 60 * 1e3;
 var DEFAULT_PLATFORM_ENDPOINT_PATH = "/v1/runtime/coworkers/{coworkerId}/participation-context";
+var DEFAULT_DELIVERY_QUIET_WINDOW_MS = 45e3;
+var DEFAULT_DELIVERY_MAX_PROGRESS_MESSAGES = 1;
+var DEFAULT_DELIVERY_PROGRESS_TEXT = "Still working on this \u2014 I\u2019ll send the result when it\u2019s complete.";
+var DEFAULT_DELIVERY_TURN_TTL_MS = 10 * 60 * 1e3;
 function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1646,6 +1650,22 @@ function normalizeContextSource(value) {
 function normalizePlatformAuthMode(value) {
   return value === "static-token" ? "static-token" : "runtime";
 }
+function normalizeDeliveryMode(value) {
+  return value === "coalesce" ? "coalesce" : "passthrough";
+}
+function normalizeDelivery(value) {
+  const record = isRecord4(value) ? value : {};
+  return {
+    mode: normalizeDeliveryMode(record.mode),
+    quietWindowMs: readPositiveInteger(record.quietWindowMs, DEFAULT_DELIVERY_QUIET_WINDOW_MS),
+    maxProgressMessages: Math.min(
+      1,
+      readPositiveInteger(record.maxProgressMessages, DEFAULT_DELIVERY_MAX_PROGRESS_MESSAGES)
+    ),
+    progressText: readString2(record.progressText) ?? DEFAULT_DELIVERY_PROGRESS_TEXT,
+    turnTtlMs: readPositiveInteger(record.turnTtlMs, DEFAULT_DELIVERY_TURN_TTL_MS) || DEFAULT_DELIVERY_TURN_TTL_MS
+  };
+}
 function normalizeClassifier(value) {
   const record = isRecord4(value) ? value : {};
   return {
@@ -1719,6 +1739,7 @@ function normalizeConfig(pluginConfig, env = process.env) {
     },
     platform: normalizePlatform(record.platform, env),
     staticContext: normalizeStaticContext(record.staticContext),
+    delivery: normalizeDelivery(record.delivery),
     logging: {
       decisions: loggingRecord.decisions !== false,
       includeContent: loggingRecord.includeContent === true,
@@ -1827,11 +1848,11 @@ function stableStringify(value) {
   return JSON.stringify(value);
 }
 function trimForPrompt(value, maxLength = 1200) {
-  const normalized = value.replace(/\s+/g, " ").trim();
-  if (normalized.length <= maxLength) {
-    return normalized;
+  const normalized2 = value.replace(/\s+/g, " ").trim();
+  if (normalized2.length <= maxLength) {
+    return normalized2;
   }
-  return `${normalized.slice(0, maxLength - 3)}...`;
+  return `${normalized2.slice(0, maxLength - 3)}...`;
 }
 function formatIdentity(identity) {
   const role = identity.roleSummary ? ` Role: ${identity.roleSummary}` : "";
@@ -2400,6 +2421,203 @@ async function decideParticipation(params) {
   }
 }
 
+// src/delivery.ts
+function createTurnDeliveryState() {
+  return {
+    turns: /* @__PURE__ */ new Map(),
+    deliveredRuns: /* @__PURE__ */ new Map()
+  };
+}
+function sharedTurnDeliveryState() {
+  const runtime = globalThis;
+  runtime.__velanirParticipationGateDeliveryV1 ??= createTurnDeliveryState();
+  return runtime.__velanirParticipationGateDeliveryV1;
+}
+function clean(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function normalized(value) {
+  return clean(value)?.toLowerCase();
+}
+function scopedKey(prefix, ...values) {
+  const parts = values.map(clean);
+  return parts.every(Boolean) ? `${prefix}:${parts.join(":")}` : void 0;
+}
+function normalizedTarget(value) {
+  const target = normalized(value);
+  if (!target) return void 0;
+  return target.replace(/^msteams:conversation:/, "").replace(/^(?:conversation|user|channel):/, "").split(";messageid=", 1)[0];
+}
+function routeProvider(route) {
+  return normalized(route.provider);
+}
+function targetMatchesRoute(target, route) {
+  const candidate = normalizedTarget(target);
+  if (!candidate) return true;
+  return [route.conversationId, route.channelId, route.senderId].some(
+    (value) => normalizedTarget(value) === candidate
+  );
+}
+function deliveryRouteForInbound(event, ctx) {
+  return {
+    provider: clean(ctx.provider) ?? clean(event.provider) ?? clean(event.surface) ?? clean(event.channel),
+    conversationId: clean(ctx.conversationId),
+    channelId: clean(ctx.channelId) ?? clean(event.channel),
+    senderId: clean(ctx.senderId) ?? clean(event.senderId)
+  };
+}
+function deliveryScopeForInbound(event, ctx) {
+  const sessionKey = clean(ctx.sessionKey) ?? clean(event.sessionKey);
+  if (sessionKey) return `session:${sessionKey}`;
+  const provider = clean(ctx.provider) ?? clean(event.provider) ?? clean(event.surface);
+  const conversationId = clean(ctx.conversationId);
+  if (provider && conversationId) {
+    return scopedKey("conversation", provider, conversationId);
+  }
+  const channelId = clean(ctx.channelId) ?? clean(event.channel);
+  return scopedKey("channel", provider, channelId);
+}
+function deliveryScopeForReply(event, ctx) {
+  const sessionKey = clean(ctx.sessionKey) ?? clean(event.sessionKey);
+  if (sessionKey) return `session:${sessionKey}`;
+  const provider = clean(event.channel);
+  const conversationId = clean(ctx.conversationId);
+  if (provider && conversationId) {
+    return scopedKey("conversation", provider, conversationId);
+  }
+  return scopedKey("channel", provider, ctx.channelId);
+}
+function deliveryScopeForTool(ctx) {
+  const sessionKey = clean(ctx.sessionKey);
+  return sessionKey ? `session:${sessionKey}` : void 0;
+}
+function deliveryScopeForMessage(ctx) {
+  const sessionKey = clean(ctx.sessionKey);
+  if (sessionKey) return `session:${sessionKey}`;
+  return scopedKey("channel", ctx.channelId, ctx.conversationId);
+}
+function createTurnDeliveryStore(config, now = Date.now, state = createTurnDeliveryState()) {
+  const { turns, deliveredRuns } = state;
+  const prune = () => {
+    const current = now();
+    for (const [scope, turn] of turns) {
+      if (current - turn.updatedAt > config.turnTtlMs) {
+        turns.delete(scope);
+      }
+    }
+    for (const [runId, deliveredAt] of deliveredRuns) {
+      if (current - deliveredAt > config.turnTtlMs) {
+        deliveredRuns.delete(runId);
+      }
+    }
+  };
+  return {
+    beginTurn(scope, route = {}) {
+      prune();
+      if (!scope) return false;
+      const timestamp = now();
+      turns.set(scope, {
+        startedAt: timestamp,
+        updatedAt: timestamp,
+        finalDelivered: false,
+        finalEgressPending: false,
+        progressMessages: 0,
+        route
+      });
+      return true;
+    },
+    abandonTurn(scope) {
+      prune();
+      return scope ? turns.delete(scope) : false;
+    },
+    decide(event, ctx) {
+      prune();
+      const scope = deliveryScopeForReply(event, ctx);
+      const turn = scope ? turns.get(scope) : void 0;
+      const runId = clean(event.runId) ?? clean(ctx.runId);
+      if (runId && deliveredRuns.has(runId)) {
+        return {
+          action: "suppress_duplicate_final",
+          result: {
+            cancel: true,
+            reason: "participation_gate_duplicate_final"
+          }
+        };
+      }
+      if (!turn) {
+        return { action: "allow_untracked" };
+      }
+      const timestamp = now();
+      turn.updatedAt = timestamp;
+      const isFinal = event.kind === void 0 || event.kind === "final";
+      if (isFinal) {
+        if (turn.finalDelivered) {
+          return {
+            action: "suppress_duplicate_final",
+            result: {
+              cancel: true,
+              reason: "participation_gate_duplicate_final"
+            }
+          };
+        }
+        turn.finalDelivered = true;
+        turn.finalEgressPending = true;
+        if (runId) deliveredRuns.set(runId, timestamp);
+        return { action: "allow_final" };
+      }
+      const canSendProgress = !turn.finalDelivered && timestamp - turn.startedAt >= config.quietWindowMs && turn.progressMessages < config.maxProgressMessages;
+      if (canSendProgress) {
+        turn.progressMessages += 1;
+        const sourcePayload = event.payload;
+        return {
+          action: "allow_progress",
+          result: {
+            payload: {
+              text: config.progressText,
+              isStatusNotice: true,
+              ...sourcePayload?.replyToId ? { replyToId: sourcePayload.replyToId } : {},
+              ...sourcePayload?.replyToTag === true ? { replyToTag: true } : {},
+              ...sourcePayload?.replyToCurrent === true ? { replyToCurrent: true } : {}
+            }
+          }
+        };
+      }
+      return {
+        action: "suppress_intermediate",
+        result: {
+          cancel: true,
+          reason: "participation_gate_suppressed_intermediate"
+        }
+      };
+    },
+    isSameConversationSend(scope, send) {
+      prune();
+      if (!scope) return false;
+      const turn = turns.get(scope);
+      if (!turn) return false;
+      const expectedProvider = routeProvider(turn.route);
+      const actualProvider = normalized(send.provider);
+      if (expectedProvider && actualProvider && expectedProvider !== actualProvider) {
+        return false;
+      }
+      return targetMatchesRoute(send.target, turn.route);
+    },
+    consumeFinalEgress(scope) {
+      prune();
+      if (!scope) return false;
+      const turn = turns.get(scope);
+      if (!turn?.finalEgressPending) return false;
+      turn.finalEgressPending = false;
+      turn.updatedAt = now();
+      return true;
+    },
+    activeTurnCount() {
+      prune();
+      return turns.size;
+    }
+  };
+}
+
 // src/history.ts
 function normalizeKey2(value) {
   const trimmed = value?.trim();
@@ -2467,13 +2685,14 @@ function outboundKeys(event, ctx) {
 function publicMessages(messages, maxMessages) {
   return messages.sort((left, right) => left.sequence - right.sequence).slice(-maxMessages).map(({ sequence: _sequence, dedupeKey: _dedupeKey, ...message2 }) => message2);
 }
-function outboundDedupeKey(event, content) {
+function outboundDedupeKey(event, ctx, content) {
+  const primaryKey = outboundKeys(event, ctx)[0];
+  if (primaryKey && primaryKey !== "unknown") {
+    return ["conversation", primaryKey, content].join("\0");
+  }
   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() {
@@ -2559,7 +2778,7 @@ function createParticipationHistoryStore() {
           content
         },
         maxMessages,
-        outboundDedupeKey(event, content)
+        outboundDedupeKey(event, ctx, content)
       );
     },
     record(event, ctx, maxMessages) {
@@ -2681,6 +2900,21 @@ function logParticipationHistoryEvent(params) {
 
 // src/index.ts
 var PLUGIN_ID = "velanir-participation-gate";
+var POST_EGRESS_REPLY_CAPTURE_PRIORITY = -100001;
+var PRE_EGRESS_DELIVERY_PRIORITY = 1e5;
+var SAME_CONVERSATION_MESSAGE_BLOCK_REASON = "Use the normal final reply for this conversation. Direct message sends to the active conversation are blocked.";
+function stringValue(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function messageToolSend(event) {
+  if (event.toolName.trim().toLowerCase() !== "message") return void 0;
+  const action = stringValue(event.params.action)?.toLowerCase();
+  if (action !== "send") return void 0;
+  return {
+    provider: stringValue(event.params.provider) ?? stringValue(event.params.channel),
+    target: stringValue(event.params.to) ?? stringValue(event.params.target) ?? stringValue(event.params.recipient) ?? stringValue(event.params.conversationId)
+  };
+}
 function replyPayloadContent(event) {
   const text = event.payload?.text;
   if (typeof text !== "string") {
@@ -2715,12 +2949,24 @@ var index_default = definePluginEntry({
     const config = normalizeConfig(runtimeApi.pluginConfig);
     const contextProvider = createParticipationContextProvider(config);
     const history = createParticipationHistoryStore();
+    const deliveries = createTurnDeliveryStore(config.delivery, Date.now, sharedTurnDeliveryState());
+    const beginDeliveryTurn = (event, ctx) => {
+      if (config.delivery.mode !== "coalesce") return;
+      const tracked = deliveries.beginTurn(
+        deliveryScopeForInbound(event, ctx),
+        deliveryRouteForInbound(event, ctx)
+      );
+      runtimeApi.logger?.info?.(
+        `[${PLUGIN_ID}-delivery] action=begin_turn tracked=${tracked} active=${deliveries.activeTurnCount()}`
+      );
+    };
     api.on(
       "before_dispatch",
       async (event, ctx) => {
         const beforeDispatchEvent = event;
         const beforeDispatchContext = ctx;
         if (beforeDispatchEvent.wasMentioned === true || beforeDispatchContext.wasMentioned === true) {
+          beginDeliveryTurn(beforeDispatchEvent, beforeDispatchContext);
           const recorded = history.recordInbound(
             beforeDispatchEvent,
             beforeDispatchContext,
@@ -2761,10 +3007,60 @@ var index_default = definePluginEntry({
         if (!decision2.shouldRespond && config.mode === "enforce") {
           return { handled: true };
         }
+        beginDeliveryTurn(beforeDispatchEvent, beforeDispatchContext);
         return void 0;
       },
       { timeoutMs: config.classifier.timeoutMs + 2e3 }
     );
+    api.on(
+      "before_tool_call",
+      (event, ctx) => {
+        if (config.delivery.mode !== "coalesce") return void 0;
+        const beforeToolCallEvent = event;
+        const send = messageToolSend(beforeToolCallEvent);
+        if (!send) return void 0;
+        const beforeToolCallContext = ctx;
+        const blocked = deliveries.isSameConversationSend(
+          deliveryScopeForTool(beforeToolCallContext),
+          send
+        );
+        if (!blocked) return void 0;
+        runtimeApi.logger?.info?.(
+          `[${PLUGIN_ID}-delivery] action=block_same_conversation_message_tool run=${beforeToolCallEvent.runId ?? beforeToolCallContext.runId ?? "unknown"} toolCall=${beforeToolCallEvent.toolCallId ?? beforeToolCallContext.toolCallId ?? "unknown"}`
+        );
+        return {
+          block: true,
+          blockReason: SAME_CONVERSATION_MESSAGE_BLOCK_REASON
+        };
+      },
+      { priority: PRE_EGRESS_DELIVERY_PRIORITY }
+    );
+    api.on(
+      "message_sending",
+      (event, ctx) => {
+        if (config.delivery.mode !== "coalesce") return void 0;
+        const messageSendingEvent = event;
+        const messageSendingContext = ctx;
+        const scope = deliveryScopeForMessage(messageSendingContext);
+        const sameConversation = deliveries.isSameConversationSend(scope, {
+          provider: messageSendingEvent.metadata?.channel,
+          target: messageSendingContext.conversationId ?? messageSendingEvent.to
+        });
+        if (!sameConversation) return void 0;
+        if (deliveries.consumeFinalEgress(scope)) {
+          runtimeApi.logger?.info?.(`[${PLUGIN_ID}-delivery] action=allow_final_message_egress`);
+          return void 0;
+        }
+        runtimeApi.logger?.info?.(
+          `[${PLUGIN_ID}-delivery] action=suppress_same_conversation_message_egress`
+        );
+        return {
+          cancel: true,
+          cancelReason: "participation_gate_suppressed_same_conversation_message"
+        };
+      },
+      { priority: PRE_EGRESS_DELIVERY_PRIORITY }
+    );
     api.on("message_sent", (event, ctx) => {
       const messageSentEvent = event;
       const messageSentContext = ctx;
@@ -2785,39 +3081,58 @@ 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) {
+    api.on(
+      "reply_payload_sending",
+      (event, ctx) => {
+        if (config.delivery.mode !== "coalesce") return void 0;
+        const decision2 = deliveries.decide(
+          event,
+          ctx
+        );
+        runtimeApi.logger?.info?.(
+          `[${PLUGIN_ID}-delivery] action=${decision2.action} kind=${event.kind ?? "legacy_final"}`
+        );
+        return decision2.result;
+      },
+      { priority: PRE_EGRESS_DELIVERY_PRIORITY }
+    );
+    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;
-      }
-      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;
-    });
+      },
+      { priority: POST_EGRESS_REPLY_CAPTURE_PRIORITY }
+    );
   }
 });
 export {

package/openclaw.plugin.json

@@ -83,6 +83,25 @@
           }
         }
       },
+      "delivery": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "mode": {
+            "type": "string",
+            "enum": ["passthrough", "coalesce"],
+            "default": "passthrough"
+          },
+          "quietWindowMs": { "type": "number", "minimum": 0, "default": 45000 },
+          "maxProgressMessages": { "type": "number", "minimum": 0, "maximum": 1, "default": 1 },
+          "progressText": {
+            "type": "string",
+            "minLength": 1,
+            "default": "Still working on this — I’ll send the result when it’s complete."
+          },
+          "turnTtlMs": { "type": "number", "minimum": 1, "default": 600000 }
+        }
+      },
       "logging": {
         "type": "object",
         "additionalProperties": false,
@@ -151,6 +170,26 @@
     "logging.classifierDebug": {
       "label": "Log Classifier Debug",
       "help": "Default off. Emits structured classifier diagnostics; exact prompt/input/output still requires includeContent."
+    },
+    "delivery.mode": {
+      "label": "Delivery Mode",
+      "help": "coalesce withholds tool and progress narration for inbound turns and emits one final answer; passthrough preserves OpenClaw delivery."
+    },
+    "delivery.quietWindowMs": {
+      "label": "Delivery Quiet Window",
+      "help": "Milliseconds to keep an inbound turn silent before one bounded progress update may be delivered."
+    },
+    "delivery.maxProgressMessages": {
+      "label": "Maximum Progress Messages",
+      "help": "Maximum user-visible progress messages per inbound turn. Supported values are 0 or 1."
+    },
+    "delivery.progressText": {
+      "label": "Progress Message",
+      "help": "Generic text used for the single long-task progress update; model-authored tool narration is never exposed."
+    },
+    "delivery.turnTtlMs": {
+      "label": "Delivery Turn TTL",
+      "help": "Maximum lifetime for per-session delivery state and duplicate-final protection."
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velanir/openclaw-participation-gate",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "OpenClaw plugin that gates group/channel participation for Velanir digital coworkers.",
   "license": "UNLICENSED",
   "type": "module",