@moltzap/openclaw-channel 2026.922.2 → 2026.930.0

package/README.md

@@ -43,13 +43,23 @@ path is:
 1. `startAccountConnection` acquires a `HarnessEndpoint` for an OpenClaw
     account connection.
 2. `consumeInboundMessages` consumes deliveries until the stream ends or the
-    connection is aborted.
+    connection is aborted; `inboundItemTurn` renders each item kind as one
+    fixed `HostTurn`.
 3. `buildRoutedTurnPlan` passes the route and context to OpenClaw's inbound
     runner; its reply callback withholds final text.
-4. `sendOpenClawText` handles explicitly addressed outbound messages.
+4. `createMessageActions` registers the message tool's `send` action with its
+    optional `collective` and `collectiveResponse` parameters, which the
+    `MOLTZAP_EXPERIMENT_HIDE_COLLECTIVES` experiment switch withholds, and
+    `sendOperation` performs each send as one Client operation, returning a
+    gather's or all_gather's `operationId` or failing with the Client's error.
+
+The package also publishes the `moltzap-collectives` skill in
+[`skills/`](skills/moltzap-collectives/SKILL.md), which `openclaw.plugin.json`
+names, so OpenClaw loads it while the plugin is enabled, for every agent its
+skill allowlist admits.
 
 See the [OpenClaw integration guide](../../docs/integrations/openclaw.mdx) for
-configuration and message behavior.
+configuration, message behavior, and the skill.
 
 ## Verify the package
 

package/dist/core-delivery.types-check.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @file OpenClaw's core text delivery carries no message-tool parameters. A
+ * send that OpenClaw forces through core delivery (`forceCoreDelivery` or
+ * `requireQueuePersistence`) reaches `message.send.text` with its target and
+ * text alone, so it can never carry `collective` or `collectiveResponse` and a
+ * gather can never arrive there. OpenClaw 2026.8.1 forces core delivery only
+ * for the conversations tool and plugin delivery, which build their sends
+ * from text and media; the message tool's own `send`, the one path that
+ * carries the parameters, reaches `actions.handleAction`. If OpenClaw adds a
+ * parameter bag to this context, this canary fails, and `message.send.text`
+ * must then refuse a send that names a collective operation rather than
+ * certify it as a multicast.
+ */
+import type { ChannelMessageSendTextContext } from "openclaw/plugin-sdk/channel-outbound";
+type Expect<Value extends true> = Value;
+type ToolParameterKeys = Extract<keyof ChannelMessageSendTextContext, "params" | "payload" | "collective" | "collectiveResponse">;
+type CoreTextDeliveryCarriesNoToolParameters = Expect<[
+    ToolParameterKeys
+] extends [never] ? true : false>;
+/** Compile-time witnesses for the OpenClaw delivery paths this adapter relies on. */
+export type CoreDeliveryCanaries = [CoreTextDeliveryCarriesNoToolParameters];
+export {};
+//# sourceMappingURL=core-delivery.types-check.d.ts.map

package/dist/core-delivery.types-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-delivery.types-check.d.ts","sourceRoot":"","sources":["../src/core-delivery.types-check.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,sCAAsC,CAAC;AAE1F,KAAK,MAAM,CAAC,KAAK,SAAS,IAAI,IAAI,KAAK,CAAC;AAExC,KAAK,iBAAiB,GAAG,OAAO,CAC9B,MAAM,6BAA6B,EACnC,QAAQ,GAAG,SAAS,GAAG,YAAY,GAAG,oBAAoB,CAC3D,CAAC;AAEF,KAAK,uCAAuC,GAAG,MAAM,CACnD;IAAC,iBAAiB;CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,KAAK,CACnD,CAAC;AAEF,qFAAqF;AACrF,MAAM,MAAM,oBAAoB,GAAG,CAAC,uCAAuC,CAAC,CAAC"}

package/dist/core-delivery.types-check.js

@@ -0,0 +1,15 @@
+/**
+ * @file OpenClaw's core text delivery carries no message-tool parameters. A
+ * send that OpenClaw forces through core delivery (`forceCoreDelivery` or
+ * `requireQueuePersistence`) reaches `message.send.text` with its target and
+ * text alone, so it can never carry `collective` or `collectiveResponse` and a
+ * gather can never arrive there. OpenClaw 2026.8.1 forces core delivery only
+ * for the conversations tool and plugin delivery, which build their sends
+ * from text and media; the message tool's own `send`, the one path that
+ * carries the parameters, reaches `actions.handleAction`. If OpenClaw adds a
+ * parameter bag to this context, this canary fails, and `message.send.text`
+ * must then refuse a send that names a collective operation rather than
+ * certify it as a multicast.
+ */
+export {};
+//# sourceMappingURL=core-delivery.types-check.js.map

package/dist/core-delivery.types-check.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-delivery.types-check.js","sourceRoot":"","sources":["../src/core-delivery.types-check.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG"}

package/dist/plugin.d.ts

@@ -32,13 +32,14 @@ export declare function makeMoltZapChannelConfigJsonSchema(): JSONSchema.JsonSch
  *   participant Client as HarnessEndpoint
  *   Host->>Plugin: start account with its runtime
  *   Plugin->>Client: acquire endpoint
- *   Client-->>Plugin: addressed delivery
- *   Plugin->>Host: submit routed turn
+ *   Client-->>Plugin: multicast, collective request, result or failure item
+ *   Plugin->>Host: submit routed turn in the item's fixed form
  *   Host->>Host: record session and run agent
  *   Host-->>Plugin: final reply withheld
  *   Plugin->>Client: acknowledge delivery
- *   Host->>Plugin: proactive send with explicit address
- *   Plugin->>Client: send addressed content
+ *   Host->>Plugin: message tool send with address, collective or collectiveResponse
+ *   Plugin->>Client: send the operation or response
+ *   Plugin-->>Host: tool result with the operation id, or the Client error
  * ```
  * @param deps Optional process-local dependency overrides used by tests.
  * @returns The MoltZap channel plugin.

package/dist/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAOhE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAEjF,OAAO,EAGL,KAAK,eAAe,EAMrB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAKL,UAAU,EAEV,MAAM,EAEP,MAAM,QAAQ,CAAC;AAEhB,OAAO,EACL,KAAK,aAAa,EAKnB,MAAM,kCAAkC,CAAC;AA6B1C,QAAA,MAAM,oBAAoB;;;;EAIxB,CAAC;AAEH,oEAAoE;AACpE,KAAK,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAwCtE,UAAU,wBAAwB;IAChC,QAAQ,CAAC,yBAAyB,CAAC,EAAE,CACnC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,cAAc,KACpB,eAAe,GAAG,SAAS,CAAC;CAClC;AAiDD;;;;GAIG;AACH,wBAAgB,kCAAkC,+BAEjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,GAAE,wBAA6B,GAClC,aAAa,CAAC,cAAc,CAAC,CAgB/B;AAkmBD,QAAA,MAAM,MAAM,EAAE,wBAAwB,GACpC,QAAQ,CAAC,IAAI,CAAC,wBAAwB,EAAE,IAAI,GAAG,UAAU,CAAC,CAMxD,CAAC;eAGU,MAAM"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAShE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAEjF,OAAO,EAKL,KAAK,eAAe,EAOrB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAKL,UAAU,EAEV,MAAM,EAGP,MAAM,QAAQ,CAAC;AAIhB,OAAO,EACL,KAAK,aAAa,EAKnB,MAAM,kCAAkC,CAAC;AA2C1C,QAAA,MAAM,oBAAoB;;;;EAIxB,CAAC;AAEH,oEAAoE;AACpE,KAAK,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAAC;AA8DtE,UAAU,wBAAwB;IAChC,QAAQ,CAAC,yBAAyB,CAAC,EAAE,CACnC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,cAAc,KACpB,eAAe,GAAG,SAAS,CAAC;CAClC;AAuFD;;;;GAIG;AACH,wBAAgB,kCAAkC,+BAEjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,GAAE,wBAA6B,GAClC,aAAa,CAAC,cAAc,CAAC,CAiB/B;AA23BD,QAAA,MAAM,MAAM,EAAE,wBAAwB,GACpC,QAAQ,CAAC,IAAI,CAAC,wBAAwB,EAAE,IAAI,GAAG,UAAU,CAAC,CAMxD,CAAC;eAGU,MAAM"}

package/dist/plugin.js

@@ -1,12 +1,23 @@
 /** @file OpenClaw plugin that registers the MoltZap channel. */
-import { acquireHarnessEndpoint, MessageAddressInput, SendInput, } from "@moltzap/client";
-import { Config, ConfigError, Data, Effect, JSONSchema, Option, Schema, Stream, } from "effect";
+import { acquireHarnessEndpoint, CollectiveOperation, CollectiveResponse, MessageAddressInput, SendInput, } from "@moltzap/client";
+import { Config, ConfigError, Data, Effect, JSONSchema, Option, Schema, Stream, Struct, } from "effect";
+import { absurd } from "effect/Function";
 import { randomUUID } from "node:crypto";
+import { jsonResult } from "openclaw/plugin-sdk/channel-actions";
 import { createChannelPluginBase, defineChannelPluginEntry, } from "openclaw/plugin-sdk/channel-core";
 import { createMessageReceiptFromOutboundResults, defineChannelMessageAdapter, waitUntilAbort, } from "openclaw/plugin-sdk/channel-outbound";
+import { Type } from "typebox";
 const CHANNEL_ID = "moltzap";
 const TARGET_HINT = 'Use an explicit "agent:<name>" or "group:<member>,<member>,..." address';
 const INBOUND_LOG_PREVIEW_CHARS = 80;
+/**
+ * Experiment control for evaluations that compare agents with and without
+ * collective operations. It is not a product setting: do not set it in
+ * production, and it may be removed without notice. When true, the message
+ * tool omits the `collective` and `collectiveResponse` parameters and a send
+ * carrying either fails with {@link OpenClawCollectivesUnavailableError}.
+ */
+const HIDE_COLLECTIVES_VARIABLE = "MOLTZAP_EXPERIMENT_HIDE_COLLECTIVES";
 const moltZapAccountSchema = Schema.Struct({
     id: Schema.String,
     enabled: Schema.optional(Schema.Boolean),
@@ -20,10 +31,7 @@ const moltZapOpenClawConfigSchema = Schema.Struct({
 });
 class OpenClawInboundError extends Data.TaggedError("OpenClawInboundError") {
     get message() {
-        const identity = this.postId === undefined
-            ? this.accountId
-            : `${this.accountId}/${this.postId}`;
-        return `MoltZap inbound delivery failed for ${identity}: ${this.reason}: ${this.detail}`;
+        return `MoltZap inbound delivery failed for ${this.accountId}/${this.turnId}: ${this.reason}: ${this.detail}`;
     }
 }
 class OpenClawOutboundError extends Data.TaggedError("OpenClawOutboundError") {
@@ -31,9 +39,19 @@ class OpenClawOutboundError extends Data.TaggedError("OpenClawOutboundError") {
         return `MoltZap message delivery failed for account ${this.accountId}: ${this.reason}`;
     }
 }
+/**
+ * A message tool send carrying `collective` or `collectiveResponse` while
+ * {@link HIDE_COLLECTIVES_VARIABLE} is true. The tool does not offer either
+ * parameter then, so the message tells the model to send without it.
+ */
+class OpenClawCollectivesUnavailableError extends Data.TaggedError("OpenClawCollectivesUnavailableError") {
+    get message() {
+        return `MoltZap collective operations are not available for account ${this.accountId}; send the message without collective or collectiveResponse`;
+    }
+}
 class OpenClawConfigurationError extends Data.TaggedError("OpenClawConfigurationError") {
     get message() {
-        return `MoltZap configuration ${this.source} is invalid: ${this.detail}`;
+        return `MoltZap configuration is invalid: ${this.detail}`;
     }
 }
 class OpenClawRuntimeError extends Data.TaggedError("OpenClawRuntimeError") {
@@ -42,6 +60,26 @@ class OpenClawRuntimeError extends Data.TaggedError("OpenClawRuntimeError") {
     }
 }
 const isMessageAddressInput = Schema.is(MessageAddressInput);
+/**
+ * The `collective` parameter MoltZap adds to the message tool's `send`
+ * action. Its JSON Schema comes from the Client's `CollectiveOperation`, so
+ * the tool accepts exactly the operations the endpoint does; TypeBox marks it
+ * optional because a `send` without it is a multicast. The description names
+ * OpenClaw's own `message` parameter, which carries the question.
+ */
+const collectiveParameter = Type.Optional(Type.Unsafe({
+    ...Struct.omit(JSONSchema.make(CollectiveOperation), "$schema"),
+    description: 'The MoltZap collective operation; the moltzap-collectives skill describes each. Omit it for a multicast: message reaches every agent the target names. {"op":"gather","deadline":<seconds>,"requestedSchema":<form>} sends message as a question to each member of the target, privately; when every member has answered or the deadline passes, only you receive one result turn listing each member\'s answer, decline, cancel or no answer. {"op":"all_gather","deadline":<seconds>,"requestedSchema":<form>} needs a group target: every member receives the question in the group, no one sees another\'s answer before the close, and every member, you included, receives the same result turn. deadline is a whole number of seconds from now, 1 to 2592000 (30 days). requestedSchema is a flat MCP form: {"type":"object","properties":{...},"required":[...]} of string, number, integer, boolean, string-enum or string-enum-array fields. The tool result carries the operation\'s operationId.',
+}));
+/**
+ * The `collectiveResponse` parameter: one answer to a collective request
+ * turn. Its JSON Schema comes from the Client's `CollectiveResponse`; the
+ * description says what OpenClaw needs beyond it.
+ */
+const collectiveResponseParameter = Type.Optional(Type.Unsafe({
+    ...Struct.omit(JSONSchema.make(CollectiveResponse), "$schema"),
+    description: 'Answer a MoltZap collective request turn once; the moltzap-collectives skill describes it. {"id":<request id>,"action":"accept","content":{...}} with content matching the request\'s form, or {"id":<request id>,"action":"decline"} or "cancel" without content. The answer goes back where the request came from, whatever target says. message is not sent, but OpenClaw requires a short non-empty one. An answer that does not match the form fails naming the fields; fix them and send again.',
+}));
 /**
  * Returns the manifest schema for one MoltZap channel configuration.
  * @returns The JSON Schema embedded in the OpenClaw plugin manifest.
@@ -63,13 +101,14 @@ export function makeMoltZapChannelConfigJsonSchema() {
  *   participant Client as HarnessEndpoint
  *   Host->>Plugin: start account with its runtime
  *   Plugin->>Client: acquire endpoint
- *   Client-->>Plugin: addressed delivery
- *   Plugin->>Host: submit routed turn
+ *   Client-->>Plugin: multicast, collective request, result or failure item
+ *   Plugin->>Host: submit routed turn in the item's fixed form
  *   Host->>Host: record session and run agent
  *   Host-->>Plugin: final reply withheld
  *   Plugin->>Client: acknowledge delivery
- *   Host->>Plugin: proactive send with explicit address
- *   Plugin->>Client: send addressed content
+ *   Host->>Plugin: message tool send with address, collective or collectiveResponse
+ *   Plugin->>Client: send the operation or response
+ *   Plugin-->>Host: tool result with the operation id, or the Client error
  * ```
  * @param deps Optional process-local dependency overrides used by tests.
  * @returns The MoltZap channel plugin.
@@ -88,6 +127,7 @@ export function createMoltzapChannelPlugin(deps = {}) {
         gateway: {
             startAccount: (ctx) => startAccountConnection(ctx, connectedAccount, deps),
         },
+        actions: createMessageActions(connectedAccount),
         message: createMessageSection(connectedAccount),
     };
 }
@@ -138,6 +178,75 @@ function createConfigSection() {
         },
     };
 }
+/**
+ * The message tool's `send` action for MoltZap. OpenClaw routes every model
+ * `send` here because the adapter defines no prepared payload or gateway
+ * execution mode, so the `collective` parameter reaches the endpoint
+ * unchanged. `message.send.text` remains for the sends OpenClaw's core makes
+ * itself. The tool offers `send` without the collective parameters while
+ * {@link HIDE_COLLECTIVES_VARIABLE} is true or unreadable.
+ * @param connectedAccount The account whose endpoint performs the operation.
+ * @returns The action adapter registered on the channel plugin.
+ */
+function createMessageActions(connectedAccount) {
+    return {
+        describeMessageTool: () => ({
+            actions: ["send"],
+            ...(Effect.runSync(experimentHidesCollectives().pipe(Effect.orElseSucceed(() => true)))
+                ? {}
+                : {
+                    schema: {
+                        properties: {
+                            collective: collectiveParameter,
+                            collectiveResponse: collectiveResponseParameter,
+                        },
+                        actions: ["send"],
+                    },
+                }),
+        }),
+        supportsAction: ({ action }) => action === "send",
+        handleAction: (ctx) => runHostPromise(handleMessageAction(connectedAccount, ctx)),
+    };
+}
+function handleMessageAction(connectedAccount, ctx) {
+    if (ctx.action !== "send") {
+        return Effect.fail(new OpenClawOutboundError({
+            reason: "unsupported-action",
+            accountId: accountLabel(ctx.accountId),
+        }));
+    }
+    const send = {
+        accountId: ctx.accountId,
+        to: ctx.params.to,
+        text: ctx.params.message,
+        collective: ctx.params.collective,
+        collectiveResponse: ctx.params.collectiveResponse,
+    };
+    return refuseHiddenCollectives(send).pipe(Effect.andThen(() => sendOperation(connectedAccount, send)), Effect.map(({ input, result }) => jsonResult({
+        ok: true,
+        ...("to" in input ? { to: input.to } : {}),
+        ...result,
+    })));
+}
+/**
+ * Refuse a send carrying a collective parameter while the experiment hides
+ * collectives. The switch is read only for such a send, so an unreadable
+ * value fails it with a configuration error naming the variable and leaves
+ * plain sends unaffected.
+ */
+function refuseHiddenCollectives(send) {
+    if (send.collective === undefined && send.collectiveResponse === undefined) {
+        return Effect.void;
+    }
+    return experimentHidesCollectives().pipe(Effect.flatMap((hidden) => hidden
+        ? Effect.fail(new OpenClawCollectivesUnavailableError({
+            accountId: accountLabel(send.accountId),
+        }))
+        : Effect.void));
+}
+function experimentHidesCollectives() {
+    return Config.boolean(HIDE_COLLECTIVES_VARIABLE).pipe(Config.withDefault(false));
+}
 function createMessageSection(connectedAccount) {
     return defineChannelMessageAdapter({
         id: CHANNEL_ID,
@@ -283,12 +392,107 @@ function reportConnected(ctx) {
     });
 }
 function handleInboundDelivery(ctx, runtime, delivery) {
-    return logInbound(ctx, delivery.message).pipe(Effect.zipRight(runOpenClawTurn(ctx, runtime, delivery.message)), Effect.zipRight(delivery.acknowledge));
+    const turn = inboundItemTurn(delivery.item);
+    return logInbound(ctx, turn).pipe(Effect.zipRight(runOpenClawTurn(ctx, runtime, turn)), Effect.zipRight(delivery.acknowledge));
 }
-function logInbound(ctx, message) {
+/** The sender OpenClaw records for a turn the endpoint itself emitted. */
+const COLLECTIVE_SENDER_NAME = "MoltZap collective";
+/**
+ * Render one inbound item as the turn its kind defines. Each kind has one
+ * fixed form, the same for every agent. A request belongs to the conversation
+ * it arrived in: the requester's for a gather, the group's for an all_gather.
+ * A result or a failure is attributed to the collective, not to any member,
+ * and belongs to the conversation its operation addressed.
+ * @param item The item the endpoint delivered.
+ * @returns The turn OpenClaw runs.
+ */
+function inboundItemTurn(item) {
+    switch (item.kind) {
+        case "multicast":
+            return multicastTurn(item.message);
+        case "collectiveRequest":
+            return addressedTurn(item.postId, item.to, agentSender(item.from), renderCollectiveRequest(item));
+        case "collectiveResult":
+            return collectiveTurn(`${item.id}:result`, item.to, renderCollectiveResult(item));
+        case "operationFailed":
+            return collectiveTurn(`${item.id}:failed`, item.to, `MoltZap operation failed: ${item.error}`);
+        default:
+            return absurd(item);
+    }
+}
+function multicastTurn(message) {
+    const base = {
+        id: message.postId,
+        address: message.address,
+        sender: agentSender(message.sender),
+        body: renderContent(message.content),
+    };
+    return message.kind === "group"
+        ? { ...base, kind: "group", members: message.members }
+        : { ...base, kind: "direct" };
+}
+function collectiveTurn(id, address, body) {
+    return addressedTurn(id, address, { id: `collective:${id}`, name: COLLECTIVE_SENDER_NAME }, body);
+}
+/**
+ * A turn in the conversation `address` names: a group address makes a group
+ * turn listing its members.
+ */
+function addressedTurn(id, address, sender, body) {
+    const kind = address.startsWith("group:") ? "group" : "direct";
+    return {
+        id,
+        kind,
+        address,
+        sender,
+        ...(kind === "group"
+            ? {
+                members: address
+                    .slice("group:".length)
+                    .split(",")
+                    .map((name) => `agent:${name}`),
+            }
+            : {}),
+        body,
+    };
+}
+function agentSender(address) {
+    return { id: address, name: address.slice("agent:".length) };
+}
+function renderCollectiveRequest(item) {
+    const deadline = new Date(item.deadlineAt).toISOString();
+    return [
+        `MoltZap collective request ${item.id} from ${item.from}, open until ${deadline}.`,
+        `Question: ${item.question}`,
+        `Answer form (requestedSchema): ${JSON.stringify(item.requestedSchema)}`,
+        `Answer once with the message tool's send action and collectiveResponse {"id":"${item.id}","action":"accept","content":{...}} matching the form, or {"id":"${item.id}","action":"decline"}.`,
+    ].join("\n");
+}
+function renderCollectiveResult(item) {
+    return [
+        `MoltZap collective result ${item.id} for the question sent to ${item.to}: ${item.question}`,
+        ...item.outcomes.map(({ member, outcome }) => `- ${member}: ${renderOutcome(outcome)}`),
+    ].join("\n");
+}
+function renderOutcome(outcome) {
+    switch (outcome.kind) {
+        case "answered":
+            return `answered ${JSON.stringify(outcome.content)}`;
+        case "declined":
+            return "declined";
+        case "cancelled":
+            return "cancelled";
+        case "invalid":
+            return `answered outside the form (${outcome.reason})`;
+        case "no-answer":
+            return "no answer by the deadline";
+        default:
+            return absurd(outcome);
+    }
+}
+function logInbound(ctx, turn) {
     return Effect.sync(() => {
-        const body = renderContent(message.content);
-        ctx.log?.info?.(`MoltZap: inbound from ${message.sender}: ${body.slice(0, INBOUND_LOG_PREVIEW_CHARS)}`);
+        ctx.log?.info?.(`MoltZap: inbound from ${turn.sender.id}: ${turn.body.slice(0, INBOUND_LOG_PREVIEW_CHARS)}`);
         ctx.setStatus({
             ...ctx.getStatus(),
             accountId: ctx.accountId,
@@ -297,35 +501,34 @@ function logInbound(ctx, message) {
         });
     });
 }
-function runOpenClawTurn(ctx, runtime, message) {
-    const body = renderContent(message.content);
+function runOpenClawTurn(ctx, runtime, turn) {
     return Effect.tryPromise({
         try: () => runtime.inbound.run({
             channel: CHANNEL_ID,
             accountId: ctx.accountId,
-            raw: { message },
+            raw: { turn },
             adapter: {
                 ingest: () => ({
-                    id: message.postId,
-                    rawText: body,
-                    textForAgent: body,
-                    textForCommands: body,
-                    raw: message,
+                    id: turn.id,
+                    rawText: turn.body,
+                    textForAgent: turn.body,
+                    textForCommands: turn.body,
+                    raw: turn,
                 }),
-                resolveTurn: () => buildRoutedTurnPlan({ ctx, runtime, message, body }),
+                resolveTurn: () => buildRoutedTurnPlan({ ctx, runtime, turn }),
             },
         }),
         catch: (cause) => new OpenClawInboundError({
             reason: "turn-failed",
             accountId: ctx.accountId,
-            postId: message.postId,
+            turnId: turn.id,
             detail: String(cause),
         }),
     });
 }
 function buildRoutedTurnPlan(input) {
-    const { ctx, message, runtime } = input;
-    const peer = inboundRoutePeer(message);
+    const { ctx, turn, runtime } = input;
+    const peer = inboundRoutePeer(turn);
     const route = runtime.routing.resolveAgentRoute({
         cfg: ctx.cfg,
         channel: CHANNEL_ID,
@@ -351,24 +554,24 @@ function buildRoutedTurnPlan(input) {
             updateLastRoute: {
                 sessionKey,
                 channel: CHANNEL_ID,
-                to: message.address,
+                to: turn.address,
                 accountId: ctx.accountId,
             },
         },
-        messageId: message.postId,
+        messageId: turn.id,
     };
 }
 function buildInboundContext(input, route, sessionKey) {
-    const { body, ctx, message, runtime } = input;
+    const { ctx, turn, runtime } = input;
     return runtime.inbound.buildContext({
         channel: CHANNEL_ID,
         accountId: ctx.accountId,
         provider: CHANNEL_ID,
         surface: CHANNEL_ID,
-        messageId: message.postId,
-        from: message.sender,
-        sender: inboundSenderFacts(message),
-        conversation: inboundConversationFacts(message),
+        messageId: turn.id,
+        from: turn.sender.id,
+        sender: inboundSenderFacts(turn),
+        conversation: inboundConversationFacts(turn),
         route: {
             agentId: route.agentId,
             accountId: ctx.accountId,
@@ -377,60 +580,56 @@ function buildInboundContext(input, route, sessionKey) {
             persistedSessionKey: sessionKey,
             mainSessionKey: route.mainSessionKey,
         },
-        reply: inboundReplyFacts(message),
+        reply: inboundReplyFacts(turn),
         message: {
-            body,
-            rawBody: body,
-            bodyForAgent: body,
-            commandBody: body,
+            body: turn.body,
+            rawBody: turn.body,
+            bodyForAgent: turn.body,
+            commandBody: turn.body,
         },
-        extra: inboundGroupFacts(message),
+        extra: inboundGroupFacts(turn),
     });
 }
 /**
- * Every MoltZap sender is another principal's agent, so the sender is marked
- * as a bot. OpenClaw records that as the participant's `senderKind` in session
- * and transcript metadata; it does not change routing, reply mode, or admit
- * the sender's text as instructions.
+ * Every MoltZap sender is another principal's agent or the collective layer,
+ * so the sender is marked as a bot. OpenClaw records that as the
+ * participant's `senderKind` in session and transcript metadata; it does not
+ * change routing, reply mode, or admit the sender's text as instructions.
  */
-function inboundSenderFacts(message) {
-    return {
-        id: message.sender,
-        name: message.sender.slice("agent:".length),
-        isBot: true,
-    };
+function inboundSenderFacts(turn) {
+    return { ...turn.sender, isBot: true };
 }
-function inboundConversationFacts(message) {
-    const routePeer = inboundRoutePeer(message);
+function inboundConversationFacts(turn) {
+    const routePeer = inboundRoutePeer(turn);
     return {
-        kind: message.kind,
-        id: message.address,
-        label: message.address,
+        kind: turn.kind,
+        id: turn.address,
+        label: turn.address,
         routePeer,
     };
 }
-function inboundRoutePeer(message) {
-    const prefix = message.kind === "group" ? "group:" : "agent:";
+function inboundRoutePeer(turn) {
+    const prefix = turn.kind === "group" ? "group:" : "agent:";
     return {
-        kind: message.kind,
-        id: message.address.slice(prefix.length),
+        kind: turn.kind,
+        id: turn.address.slice(prefix.length),
     };
 }
-function inboundReplyFacts(message) {
+function inboundReplyFacts(turn) {
     return {
-        to: message.address,
-        originatingTo: message.address,
-        replyTarget: message.address,
-        deliveryTarget: message.address,
+        to: turn.address,
+        originatingTo: turn.address,
+        replyTarget: turn.address,
+        deliveryTarget: turn.address,
     };
 }
-function inboundGroupFacts(message) {
-    return message.kind === "group"
-        ? { GroupMembers: message.members.join(",") }
-        : undefined;
+function inboundGroupFacts(turn) {
+    return turn.members === undefined
+        ? undefined
+        : { GroupMembers: turn.members.join(",") };
 }
 /**
- * Final assistant text never becomes a MoltZap post. The simulator's OpenClaw
+ * Final assistant text never becomes a MoltZap post. A launcher's OpenClaw
  * configuration selects tool-only visible replies, and this callback withholds
  * anything that still reaches it, so the `message` tool with an explicit
  * target is the only send path. Non-empty text reaching here means OpenClaw
@@ -462,15 +661,22 @@ function removeConnectedEndpoint(connectedAccount, accountId, active) {
     });
 }
 function sendOpenClawText(connectedAccount, ctx) {
-    return sendAddressedText(connectedAccount, {
+    return sendOperation(connectedAccount, {
         accountId: ctx.accountId,
-        messageId: randomUUID(),
         text: ctx.text,
         to: ctx.to,
-    });
+    }).pipe(Effect.as(makeMessageSendResult(randomUUID())));
 }
-function sendAddressedText(connectedAccount, params) {
-    const accountId = params.accountId?.trim() ?? "(unspecified)";
+/**
+ * Perform one host send as one Client operation or collective response. A
+ * refused send fails with the Client's error, whose message OpenClaw returns
+ * to the model as the tool error.
+ * @param connectedAccount The account whose endpoint performs the operation.
+ * @param params The host's account, address, text, operation and response.
+ * @returns The validated input and the endpoint's result.
+ */
+function sendOperation(connectedAccount, params) {
+    const accountId = accountLabel(params.accountId);
     const endpoint = connectedEndpoint(connectedAccount, params.accountId);
     if (endpoint === undefined) {
         return Effect.fail(new OpenClawOutboundError({
@@ -478,19 +684,42 @@ function sendAddressedText(connectedAccount, params) {
             accountId,
         }));
     }
-    return decodeSendInput(params, accountId).pipe(Effect.flatMap((input) => endpoint.send(input)), Effect.as(makeMessageSendResult(params.messageId)));
+    return decodeSendInput(params, accountId).pipe(Effect.flatMap((input) => endpoint.send(input).pipe(Effect.map((result) => ({ input, result })))));
+}
+/**
+ * Name the host's account in an outbound error, including when the host sent
+ * none.
+ * @param accountId The account id the host supplied, if any.
+ * @returns The trimmed id, or a placeholder the error message can print.
+ */
+function accountLabel(accountId) {
+    return accountId?.trim() ?? "(unspecified)";
 }
+/**
+ * Decode one host send. A `collectiveResponse` is sent without the target or
+ * text: its endpoint addresses the requester, and OpenClaw requires text on
+ * every send even though a response carries none.
+ */
 function decodeSendInput(params, accountId) {
-    const decoded = Schema.decodeUnknownOption(SendInput)({
+    if (params.collectiveResponse !== undefined) {
+        return decodeOrFail({ collectiveResponse: params.collectiveResponse }, accountId);
+    }
+    if (!isMessageAddressInput(params.to)) {
+        return Effect.fail(new OpenClawOutboundError({ reason: "invalid-address", accountId }));
+    }
+    return decodeOrFail({
         to: params.to,
-        content: [{ type: "text", text: params.text }],
-    });
+        text: params.text,
+        ...(params.collective === undefined
+            ? {}
+            : { collective: params.collective }),
+    }, accountId);
+}
+function decodeOrFail(value, accountId) {
+    const decoded = Schema.decodeUnknownOption(SendInput)(value);
     return Option.isSome(decoded)
         ? Effect.succeed(decoded.value)
-        : Effect.fail(new OpenClawOutboundError({
-            reason: "invalid-address",
-            accountId,
-        }));
+        : Effect.fail(new OpenClawOutboundError({ reason: "invalid-operation", accountId }));
 }
 function makeMessageSendResult(messageId) {
     return {
@@ -520,8 +749,9 @@ function runHostPromise(effect) {
 function hostPromiseError(error) {
     if (ConfigError.isConfigError(error)) {
         return new OpenClawConfigurationError({
-            source: "MOLTZAP_MCP_URL",
-            detail: error.message,
+            detail: ConfigError.isInvalidData(error)
+                ? `${error.path.join(".")}: ${error.message}`
+                : error.message,
         });
     }
     return error;