@brantrusnak/openclaw-omadeus 1.0.5 → 1.0.6

package/dist/src/api/message.api.js

@@ -16,7 +16,7 @@ async function sendRoomMessage(opts, params) {
 			method: "SEND",
 			body: JSON.stringify({
 				body: params.body,
-				temporaryId: generateTemporaryId(),
+				temporaryId: params.temporaryId ?? generateTemporaryId(),
 				links: "[]"
 			})
 		});
@@ -38,6 +38,17 @@ async function sendRoomMessage(opts, params) {
 		};
 	}
 }
+async function seeMessage(opts, params) {
+	const res = await jaguarFetch(opts, `/messages/${params.messageId}`, {
+		method: "SEE",
+		body: "{}"
+	});
+	if (!res.ok) {
+		const text = await res.text().catch(() => "");
+		throw new Error(`Omadeus see message failed (${res.status}): ${text.slice(0, 200)}`);
+	}
+	return await res.json();
+}
 async function editMessage(opts, params) {
 	const res = await jaguarFetch(opts, `/messages/${params.messageId}`, {
 		method: "EDIT",
@@ -73,4 +84,4 @@ async function addMessageReaction(opts, params) {
 	return readJsonOrEmpty(res);
 }
 //#endregion
-export { addMessageReaction, deleteMessage, editMessage, sendRoomMessage };
+export { addMessageReaction, deleteMessage, editMessage, seeMessage, sendRoomMessage };

package/dist/src/channel.js

@@ -1,5 +1,6 @@
 import { DEFAULT_ACCOUNT_ID, missingTargetError } from "../runtime-api.js";
 import { ALLOWED_OMADEUS_REACTION_EMOJI_LIST, isAllowedOmadeusReactionEmoji } from "./allowed-reaction-emojis.js";
+import { generateTemporaryId } from "./utils/http.util.js";
 import { createNugget, resolveTaskRoomIdByNumber } from "./api/nugget.api.js";
 import { addMessageReaction, deleteMessage, editMessage } from "./api/message.api.js";
 import { getOmadeusChannelConfig, listOmadeusAccountIds, resolveDefaultOmadeusAccountId, resolveOmadeusAccount } from "./config.js";
@@ -8,6 +9,7 @@ import { parseTaskChannelTargetIntent } from "./nugget-lookup.js";
 import { sendOmadeusMessage } from "./outbound.js";
 import { getOmadeusRuntime } from "./runtime.js";
 import { createOmadeusMessageHandler } from "./message-handler.js";
+import { SentMessageTracker } from "./sent-message-tracker.js";
 import { omadeusSetupAdapter } from "./setup-core.js";
 import { omadeusSetupWizard } from "./onboarding.js";
 import "./setup-surface.js";
@@ -23,7 +25,8 @@ const CHANNEL_ID = "omadeus";
 const gatewayState = {
 	tokenManager: null,
 	dolphin: null,
-	jaguar: null
+	jaguar: null,
+	sentTracker: null
 };
 const isUnconfigured = (account) => account.credentialSource === "none";
 let lastPersistedToken = null;
@@ -251,10 +254,17 @@ const omadeusPlugin = {
 				if (messageId == null) return actionError("Omadeus edit requires `messageId` (Jaguar message id) or current inbound MessageSid.", "Missing messageId for edit.");
 				if (!body) return actionError("Omadeus edit requires new text in `message`, `text`, or `content`.", "Missing body for edit.");
 				try {
-					await editMessage(apiOpts(), {
-						messageId,
+					const temporaryId = generateTemporaryId();
+					gatewayState.sentTracker?.trackOutbound({
+						temporaryId,
 						body
 					});
+					const edited = await editMessage(apiOpts(), {
+						messageId,
+						body,
+						temporaryId
+					});
+					if (typeof edited?.id === "number") gatewayState.sentTracker?.trackId(edited.id);
 				} catch (err) {
 					return actionError(err instanceof Error ? err.message : String(err));
 				}
@@ -376,7 +386,8 @@ const omadeusPlugin = {
 						maestroUrl: resolveOmadeusAccount({ cfg }).maestroUrl,
 						tokenManager: gatewayState.tokenManager
 					},
-					jaguarSocket: gatewayState.jaguar
+					jaguarSocket: gatewayState.jaguar,
+					sentTracker: gatewayState.sentTracker ?? void 0
 				}, {
 					to,
 					text
@@ -500,12 +511,15 @@ const omadeusPlugin = {
 		tokenManager.startAutoRefresh();
 		gatewayState.tokenManager = tokenManager;
 		const selfReferenceId = tokenManager.getPayload().referenceId;
+		const sentTracker = new SentMessageTracker();
+		gatewayState.sentTracker = sentTracker;
 		const outboundDeps = {
 			apiOpts: {
 				maestroUrl: account.maestroUrl,
 				tokenManager
 			},
-			jaguarSocket: null
+			jaguarSocket: null,
+			sentTracker
 		};
 		const handleMessage = createOmadeusMessageHandler({
 			cfg,
@@ -521,6 +535,16 @@ const omadeusPlugin = {
 			onMessage: (msg) => {
 				const label = msg.subscribableKind === "direct" ? `DM from ${msg.senderReferenceId}` : `${msg.subscribableKind}/${msg.roomName ?? msg.roomId} from ${msg.senderReferenceId}`;
 				log.info(`[jaguar] ${label}: ${msg.body.slice(0, 80)}`);
+				if (sentTracker.isEcho({
+					id: msg.id,
+					temporaryId: msg.temporaryId,
+					body: msg.body,
+					roomId: msg.roomId,
+					fromSelf: msg.senderReferenceId === selfReferenceId
+				})) {
+					log.debug?.(`[jaguar] suppressed self-echo id=${msg.id}`);
+					return;
+				}
 				const inbound = parseJaguarMessage(msg, { selfReferenceId }, log);
 				if (inbound) {
 					log.info(`[jaguar] inbound: ${inbound.subscribableKind} room=${inbound.roomId} from=${inbound.from} mention=${inbound.isMention}`);
@@ -607,6 +631,7 @@ const omadeusPlugin = {
 			gatewayState.tokenManager = null;
 			gatewayState.jaguar = null;
 			gatewayState.dolphin = null;
+			gatewayState.sentTracker = null;
 			lastPersistedToken = null;
 			ctx.setStatus({
 				accountId: account.accountId,

package/dist/src/inbound-policy.js

@@ -42,7 +42,8 @@ function surfaceForKind(kind) {
 	if (kind === "channel") return "channel";
 	return "entity";
 }
-function senderAllowed(allowed, fromReferenceId) {
+function senderAllowed(allowed, fromReferenceId, selfReferenceId) {
+	if (fromReferenceId === selfReferenceId) return true;
 	if (!allowed || allowed.length === 0) return true;
 	return allowed.includes(fromReferenceId);
 }
@@ -85,18 +86,14 @@ function mentionRequired(params) {
 }
 /**
 * Evaluate whether a normalized Jaguar inbound should be dispatched to OpenClaw.
-* Callers must drop self-authored messages separately if they prefer logging there.
+*
+* The logged-in user (`selfReferenceId`) is always treated as an allowed sender
+* so they can message their own OpenClaw even if the stored allowlist predates
+* them. Self-authored *echoes* (the reply loop) are filtered earlier, at socket
+* ingestion, by the {@link SentMessageTracker} — not here.
 */
 function evaluateOmadeusInboundPolicy(params) {
 	const { inbound, omadeusCfg, selfReferenceId } = params;
-	if (inbound.fromReferenceId === selfReferenceId) return {
-		allow: false,
-		reason: "self_message",
-		details: {
-			fromReferenceId: inbound.fromReferenceId,
-			selfReferenceId
-		}
-	};
 	const policy = mergePolicy(omadeusCfg);
 	const surface = surfaceForKind(inbound.subscribableKind);
 	if (surface === "direct") {
@@ -105,7 +102,7 @@ function evaluateOmadeusInboundPolicy(params) {
 			reason: "direct_disabled",
 			details: { surface }
 		};
-		if (!senderAllowed(policy.direct.allowedSenderReferenceIds, inbound.fromReferenceId)) return {
+		if (!senderAllowed(policy.direct.allowedSenderReferenceIds, inbound.fromReferenceId, selfReferenceId)) return {
 			allow: false,
 			reason: "direct_sender_not_allowed",
 			details: { fromReferenceId: inbound.fromReferenceId }
@@ -128,7 +125,7 @@ function evaluateOmadeusInboundPolicy(params) {
 			reason: "channels_disabled",
 			details: { surface }
 		};
-		if (!senderAllowed(policy.channels.allowedSenderReferenceIds, inbound.fromReferenceId)) return {
+		if (!senderAllowed(policy.channels.allowedSenderReferenceIds, inbound.fromReferenceId, selfReferenceId)) return {
 			allow: false,
 			reason: "channel_sender_not_allowed",
 			details: { fromReferenceId: inbound.fromReferenceId }
@@ -139,7 +136,7 @@ function evaluateOmadeusInboundPolicy(params) {
 			allowedRoomIds: policy.channels.allowedRoomIds,
 			allowedChannelViewIds: policy.channels.allowedChannelViewIds
 		});
-		const senderInList = !policy.channels.allowedSenderReferenceIds || policy.channels.allowedSenderReferenceIds.length === 0 || policy.channels.allowedSenderReferenceIds.includes(inbound.fromReferenceId);
+		const senderInList = inbound.fromReferenceId === selfReferenceId || !policy.channels.allowedSenderReferenceIds || policy.channels.allowedSenderReferenceIds.length === 0 || policy.channels.allowedSenderReferenceIds.includes(inbound.fromReferenceId);
 		const inAllowlist = rv.geoInAllowlist && senderInList;
 		const channelMention = policy.channels.requireMention ?? DEFAULT_INBOUND_POLICY.channels.requireMention;
 		if (mentionRequired({
@@ -170,7 +167,7 @@ function evaluateOmadeusInboundPolicy(params) {
 			allowedKinds: policy.entities.allowedKinds
 		}
 	};
-	if (!senderAllowed(policy.entities.allowedSenderReferenceIds, inbound.fromReferenceId)) return {
+	if (!senderAllowed(policy.entities.allowedSenderReferenceIds, inbound.fromReferenceId, selfReferenceId)) return {
 		allow: false,
 		reason: "entity_sender_not_allowed",
 		details: { fromReferenceId: inbound.fromReferenceId }

package/dist/src/message-handler.js

@@ -1,5 +1,6 @@
 import { logInboundDrop, resolveControlCommandGate } from "../runtime-api.js";
 import { createNugget, findNuggetByTaskChannelRoom, resolveTaskChannelRoomId, searchNuggetByNumber } from "./api/nugget.api.js";
+import { seeMessage } from "./api/message.api.js";
 import { getOmadeusChannelConfig } from "./config.js";
 import { appendNuggetContextForTaskOrNuggetRoom, appendNuggetLookupContextForAgent, parseChannelTaskCreateIntent, parseNuggetLookupIntent, parseRecurringScheduleIntent } from "./nugget-lookup.js";
 import { getOmadeusRuntime } from "./runtime.js";
@@ -36,7 +37,17 @@ function createOmadeusMessageHandler(deps) {
 		cfg,
 		channel: "omadeus"
 	});
-	const handleMessageNow = async (inbound) => {
+	/** Mark inbound messages as seen in Omadeus (fire-and-forget). */
+	const markMessagesSeen = (messageIds) => {
+		for (const messageId of messageIds) {
+			if (!Number.isFinite(messageId)) continue;
+			log.info(`omadeus: marking message ${messageId} seen`);
+			seeMessage(outboundDeps.apiOpts, { messageId }).then(() => log.debug?.(`omadeus: marked message ${messageId} seen`)).catch((err) => {
+				log.warn(`omadeus: failed to mark message ${messageId} seen: ${err instanceof Error ? err.message : String(err)}`);
+			});
+		}
+	};
+	const handleMessageNow = async (inbound, ackMessageIds = [inbound.messageId]) => {
 		const isDirectMessage = inbound.subscribableKind === "direct";
 		const senderId = String(inbound.fromReferenceId);
 		const senderName = inbound.from;
@@ -77,6 +88,7 @@ function createOmadeusMessageHandler(deps) {
 			});
 			return;
 		}
+		if (inbound.fromReferenceId !== selfReferenceId) markMessagesSeen(ackMessageIds);
 		let bodyForAgent = rawBody;
 		const createIntent = parseChannelTaskCreateIntent(rawBody);
 		if (createIntent) try {
@@ -248,7 +260,7 @@ function createOmadeusMessageHandler(deps) {
 				...last,
 				content: combinedContent,
 				isMention: entries.some((e) => e.isMention)
-			});
+			}, entries.map((e) => e.messageId));
 		},
 		onError: (err) => {
 			runtime.error?.(`omadeus debounce flush failed: ${String(err)}`);

package/dist/src/onboarding.js

@@ -152,28 +152,43 @@ async function promptCredentials(prompter, existing) {
 		})).trim()
 	};
 }
-async function promptSenderAllowlist(params) {
-	const { prompter, message, members, existingReferenceIds } = params;
-	if (members.length === 0) throw new Error("No organization members found.");
-	if (await prompter.select({
-		message,
-		options: [{
-			value: "all",
-			label: "All users",
-			hint: "No sender allowlist"
-		}, {
-			value: "specific",
-			label: "Specific users",
-			hint: "Select one or more users"
-		}],
-		initialValue: existingReferenceIds && existingReferenceIds.length > 0 ? "specific" : "all"
-	}) === "all") return;
-	return readReferenceIds(await promptMultiSelect({
-		prompter,
-		message: `${message} (specific users)`,
-		options: memberOptions(members),
-		initialValues: existingReferenceIds?.map(String)
-	}));
+/**
+* Prompt for the set of users allowed to message this OpenClaw instance.
+*
+* This single allowlist governs direct messages, channels, and entity rooms.
+* There is no "all users" option: only whitelisted members may message
+* OpenClaw. The logged-in user is always added
+* to the allowlist (and is excluded from the selectable list by the caller) so
+* they can interact with their own OpenClaw. Self-authored echoes (the reply
+* loop) are filtered earlier, at socket ingestion, by the SentMessageTracker —
+* not by the inbound policy — so allowing yourself here cannot cause a loop.
+*/
+async function promptMessagingAllowlist(params) {
+	const { prompter, members, selfReferenceId, existingReferenceIds } = params;
+	let selected = [];
+	if (members.length === 0) await prompter.note("No other organization members found. Only you will be able to message OpenClaw.", "Omadeus messaging allowlist");
+	else {
+		const memberReferenceIds = new Set(members.map((member) => member.referenceId));
+		const initialValues = (existingReferenceIds ?? []).filter((id) => id !== selfReferenceId && memberReferenceIds.has(id)).map(String);
+		selected = readReferenceIds(await promptMultiSelect({
+			prompter,
+			message: "Which users do you want to be able to message this OpenClaw instance? (You are always allowed.)",
+			options: memberOptions(members),
+			initialValues
+		}));
+	}
+	return Array.from(new Set([selfReferenceId, ...selected]));
+}
+/**
+* Ask whether an @mention is required to trigger OpenClaw in a given surface
+* (channels or entity rooms). DMs never use this — you can't @mention in a DM.
+*/
+async function promptRequireMention(params) {
+	if (params.existing === "outsideAllowlist") return "outsideAllowlist";
+	return await params.prompter.confirm({
+		message: `Require an @mention to trigger OpenClaw in ${params.surfaceLabel}?`,
+		initialValue: params.existing ? params.existing !== "never" : true
+	}) ? "always" : "never";
 }
 async function promptEntityKindSelection(params) {
 	const selected = await promptMultiSelect({
@@ -269,11 +284,15 @@ const omadeusSetupWizard = {
 			excludeReferenceIds: [selfReferenceId]
 		});
 		const existingInbound = section.inbound;
-		const directSenderIds = await promptSenderAllowlist({
+		const allowedUserReferenceIds = await promptMessagingAllowlist({
 			prompter,
-			message: "Which users can DM OpenClaw directly?",
 			members,
-			existingReferenceIds: existingInbound?.direct?.allowedSenderReferenceIds
+			selfReferenceId,
+			existingReferenceIds: Array.from(new Set([
+				...existingInbound?.direct?.allowedSenderReferenceIds ?? [],
+				...existingInbound?.channels?.allowedSenderReferenceIds ?? [],
+				...existingInbound?.entities?.allowedSenderReferenceIds ?? []
+			]))
 		});
 		const selectedChannels = await promptChannelSelection({
 			prompter,
@@ -282,33 +301,34 @@ const omadeusSetupWizard = {
 			memberReferenceId: selfReferenceId,
 			existingChannelViewIds: existingInbound?.channels?.allowedChannelViewIds
 		});
-		const channelSenderIds = selectedChannels.length > 0 ? await promptSenderAllowlist({
+		const channelSenderIds = selectedChannels.length > 0 ? allowedUserReferenceIds : void 0;
+		const channelRequireMention = selectedChannels.length > 0 ? await promptRequireMention({
 			prompter,
-			message: "Which users can trigger OpenClaw from allowed channels?",
-			members,
-			existingReferenceIds: existingInbound?.channels?.allowedSenderReferenceIds
-		}) : void 0;
+			surfaceLabel: "allowed channels",
+			existing: existingInbound?.channels?.requireMention
+		}) : "never";
 		const entityKinds = await promptEntityKindSelection({
 			prompter,
 			existingKinds: existingInbound?.entities?.allowedKinds
 		});
-		const entitySenderIds = entityKinds.length > 0 ? await promptSenderAllowlist({
+		const entitySenderIds = entityKinds.length > 0 ? allowedUserReferenceIds : void 0;
+		const entityRequireMention = entityKinds.length > 0 ? await promptRequireMention({
 			prompter,
-			message: "Which users can trigger OpenClaw from entity rooms?",
-			members,
-			existingReferenceIds: existingInbound?.entities?.allowedSenderReferenceIds
-		}) : void 0;
+			surfaceLabel: "entity rooms",
+			existing: existingInbound?.entities?.requireMention
+		}) : "never";
 		const channelRoomIds = selectedChannels.flatMap((selectedChannel) => [selectedChannel.publicRoomId, selectedChannel.privateRoomId]).filter((id) => typeof id === "number");
 		const channelViewIds = selectedChannels.map((selectedChannel) => selectedChannel.id);
 		const channelTitles = selectedChannels.map((selectedChannel) => selectedChannel.title || `Channel ${selectedChannel.id}`).join(", ");
 		const senderSummary = (ids) => ids && ids.length > 0 ? ids.join(", ") : "all users";
-		const entityKindSummary = entityKinds.length > 0 ? entityKinds.join(", ") : "none (entity rooms disabled)";
-		const channelSummary = selectedChannels.length > 0 ? `- Channels "${channelTitles}": rooms ${channelRoomIds.join(", ") || "(no room ids)"} from ${senderSummary(channelSenderIds)}; @mention not required in those rooms.` : "- Channels: disabled (none selected).";
+		const mentionSummary = (require) => require === "never" ? "no @mention required" : require === "outsideAllowlist" ? "@mention required outside the allowlist" : "@mention required";
+		const channelSummary = selectedChannels.length > 0 ? `- Channels "${channelTitles}": rooms ${channelRoomIds.join(", ") || "(no room ids)"} from ${senderSummary(channelSenderIds)}; ${mentionSummary(channelRequireMention)}.` : "- Channels: disabled (none selected).";
+		const entitySummary = entityKinds.length > 0 ? `- Entity rooms (${entityKinds.join(", ")}): ${senderSummary(entitySenderIds)}; ${mentionSummary(entityRequireMention)}.` : "- Entity rooms: disabled (no room types selected).";
 		await prompter.note([
 			`Inbound policy (Jaguar chat):`,
-			`- Direct messages: enabled for ${senderSummary(directSenderIds)} (no @mention required).`,
+			`- Direct messages: enabled for ${senderSummary(allowedUserReferenceIds)}.`,
 			channelSummary,
-			`- Entity rooms (${entityKindSummary}): ${senderSummary(entitySenderIds)}; @mention required.`
+			entitySummary
 		].join("\n"), "Omadeus inbound policy");
 		next = {
 			...next,
@@ -326,7 +346,7 @@ const omadeusSetupWizard = {
 						version: 1,
 						direct: {
 							enabled: true,
-							...directSenderIds ? { allowedSenderReferenceIds: directSenderIds } : {},
+							allowedSenderReferenceIds: allowedUserReferenceIds,
 							requireMention: "never"
 						},
 						channels: {
@@ -334,13 +354,13 @@ const omadeusSetupWizard = {
 							allowedRoomIds: channelRoomIds,
 							allowedChannelViewIds: channelViewIds,
 							...channelSenderIds ? { allowedSenderReferenceIds: channelSenderIds } : {},
-							requireMention: "outsideAllowlist"
+							requireMention: channelRequireMention
 						},
 						entities: {
 							enabled: entityKinds.length > 0,
 							allowedKinds: entityKinds,
 							...entitySenderIds ? { allowedSenderReferenceIds: entitySenderIds } : {},
-							requireMention: "always"
+							requireMention: entityRequireMention
 						}
 					}
 				}

package/dist/src/outbound.js

@@ -1,12 +1,21 @@
+import { generateTemporaryId } from "./utils/http.util.js";
 import { sendRoomMessage } from "./api/message.api.js";
 //#region src/outbound.ts
 async function sendOmadeusMessage(deps, params) {
 	const { to, text } = params;
+	const temporaryId = generateTemporaryId();
+	deps.sentTracker?.trackOutbound({
+		temporaryId,
+		body: text,
+		roomId: to
+	});
 	const result = await sendRoomMessage(deps.apiOpts, {
 		roomId: to,
-		body: text
+		body: text,
+		temporaryId
 	});
 	if (!result.ok) throw new Error(`Omadeus send failed: ${result.error}`);
+	if (typeof result.message?.id === "number") deps.sentTracker?.trackId(result.message.id);
 	return {
 		channel: "omadeus",
 		messageId: String(result.message?.id ?? ""),

package/dist/src/sent-message-tracker.js

@@ -0,0 +1,116 @@
+//#region src/sent-message-tracker.ts
+/**
+* Tracks messages this plugin sent so their Jaguar socket echoes can be
+* suppressed, instead of dropping every message authored by the logged-in
+* account.
+*
+* OpenClaw sends as the same Omadeus account it listens on, so each outbound
+* message is broadcast back to us over the socket. We register up to three keys
+* per send:
+*
+* - the client-generated `temporaryId` — known *before* the HTTP round-trip, so
+*   it matches even when the socket echo beats the send response (the common
+*   race);
+* - the backend message `id` — known once the send response returns;
+* - a normalized copy of the body scoped to its room — a last-resort fallback
+*   used only for self-authored echoes that somehow arrive without a
+*   recognizable id. Scoping by room prevents the same text sent in one chat
+*   from suppressing an identical message in a different chat.
+*
+* `id` and `temporaryId` are kept in separate maps. Entries expire after a
+* short TTL and each map is size-capped, so the tracker cannot grow unbounded.
+*/
+const DEFAULT_TTL_MS = 120 * 1e3;
+const DEFAULT_MAX_ENTRIES = 500;
+function normalizeContent(body) {
+	return body.trim();
+}
+/** Normalize a room identity so outbound (`"room:123"`/`"123"`) and the socket
+* echo (numeric `123`) map to the same key. */
+function roomKey(roomId) {
+	return String(roomId).replace(/^room:/, "").trim();
+}
+/** Build the room-scoped content key, or undefined when the body is empty. */
+function contentKey(roomId, body) {
+	const normalized = normalizeContent(body);
+	if (!normalized) return void 0;
+	return `${roomKey(roomId)}\n${normalized}`;
+}
+var SentMessageTracker = class {
+	ttlMs;
+	maxEntries;
+	now;
+	ids = /* @__PURE__ */ new Map();
+	temporaryIds = /* @__PURE__ */ new Map();
+	contents = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		this.ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+		this.maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+		this.now = options.now ?? Date.now;
+	}
+	/** Register a client-generated temporaryId. Call before sending. */
+	trackTemporaryId(temporaryId) {
+		if (!temporaryId) return;
+		this.remember(this.temporaryIds, temporaryId);
+	}
+	/** Register the backend message id once the send response returns. */
+	trackId(id) {
+		if (!Number.isFinite(id)) return;
+		this.remember(this.ids, id);
+	}
+	/** Register a message body, scoped to its room, as a fallback match key. */
+	trackContent(roomId, body) {
+		const key = contentKey(roomId, body);
+		if (!key) return;
+		this.remember(this.contents, key);
+	}
+	/** Convenience: register whichever keys are available for one outbound message. */
+	trackOutbound(params) {
+		if (params.temporaryId) this.trackTemporaryId(params.temporaryId);
+		if (typeof params.id === "number") this.trackId(params.id);
+		if (typeof params.body === "string" && params.roomId !== void 0) this.trackContent(params.roomId, params.body);
+	}
+	/**
+	* Returns true when an inbound socket message is an echo of something we sent.
+	*
+	* `id`/`temporaryId` matches are authoritative. The content fallback only
+	* applies to self-authored messages — the only ones that can form a reply
+	* loop — and is scoped to the message's room, so a different user repeating
+	* our text (or the same text in another room) is never suppressed.
+	*/
+	isEcho(msg) {
+		if (typeof msg.id === "number" && this.has(this.ids, msg.id)) return true;
+		if (msg.temporaryId && this.has(this.temporaryIds, msg.temporaryId)) return true;
+		if (msg.fromSelf && typeof msg.body === "string" && msg.roomId !== void 0) {
+			const key = contentKey(msg.roomId, msg.body);
+			if (key && this.has(this.contents, key)) return true;
+		}
+		return false;
+	}
+	remember(map, key) {
+		map.delete(key);
+		map.set(key, this.now() + this.ttlMs);
+		this.prune(map);
+	}
+	has(map, key) {
+		const expiry = map.get(key);
+		if (expiry === void 0) return false;
+		if (expiry <= this.now()) {
+			map.delete(key);
+			return false;
+		}
+		return true;
+	}
+	prune(map) {
+		const now = this.now();
+		for (const [key, expiry] of map) if (expiry <= now) map.delete(key);
+		else break;
+		while (map.size > this.maxEntries) {
+			const oldest = map.keys().next().value;
+			if (oldest === void 0) break;
+			map.delete(oldest);
+		}
+	}
+};
+//#endregion
+export { SentMessageTracker };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brantrusnak/openclaw-omadeus",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "private": false,
   "description": "OpenClaw Omadeus project management channel plugin",
   "homepage": "https://github.com/brantrusnak/openclaw-omadeus-plugin#readme",

package/src/api/message.api.ts

@@ -19,14 +19,14 @@ async function readJsonOrEmpty(res: Response): Promise<unknown> {
 
 export async function sendRoomMessage(
   opts: OmadeusApiOptions,
-  params: { roomId: number | string; body: string },
+  params: { roomId: number | string; body: string; temporaryId?: string },
 ): Promise<{ ok: boolean; message?: OmadeusMessage; error?: string }> {
   try {
     const res = await jaguarFetch(opts, `/rooms/${params.roomId}/messages`, {
       method: "SEND",
       body: JSON.stringify({
         body: params.body,
-        temporaryId: generateTemporaryId(),
+        temporaryId: params.temporaryId ?? generateTemporaryId(),
         links: "[]",
       }),
     });
@@ -68,6 +68,8 @@ export async function seeMessage(
 ): Promise<OmadeusMessage> {
   const res = await jaguarFetch(opts, `/messages/${params.messageId}`, {
     method: "SEE",
+    // The server requires a Content-Length header; an empty JSON body supplies one.
+    body: "{}",
   });
   if (!res.ok) {
     const text = await res.text().catch(() => "");

package/src/channel.ts

@@ -27,6 +27,7 @@ import {
   type OmadeusNuggetPriority,
 } from "./api/nugget.api.js";
 import { addMessageReaction, deleteMessage, editMessage } from "./api/message.api.js";
+import { generateTemporaryId } from "./utils/http.util.js";
 import {
   getOmadeusChannelConfig,
   listOmadeusAccountIds,
@@ -38,6 +39,7 @@ import { createOmadeusMessageHandler } from "./message-handler.js";
 import { parseTaskChannelTargetIntent } from "./nugget-lookup.js";
 import { sendOmadeusMessage, type OutboundDeps } from "./outbound.js";
 import { getOmadeusRuntime } from "./runtime.js";
+import { SentMessageTracker } from "./sent-message-tracker.js";
 import { omadeusSetupAdapter } from "./setup-core.js";
 import { omadeusSetupWizard } from "./setup-surface.js";
 import { createDolphinSocketClient, type DolphinSocketClient } from "./socket/dolphin.socket.js";
@@ -51,7 +53,8 @@ const gatewayState: {
   tokenManager: OmadeusTokenManager | null;
   dolphin: DolphinSocketClient | null;
   jaguar: JaguarSocketClient | null;
-} = { tokenManager: null, dolphin: null, jaguar: null };
+  sentTracker: SentMessageTracker | null;
+} = { tokenManager: null, dolphin: null, jaguar: null, sentTracker: null };
 
 const isUnconfigured = (account: Account) => account.credentialSource === "none";
 
@@ -319,7 +322,13 @@ export const omadeusPlugin: ChannelPlugin<Account> = {
           );
         }
         try {
-          await editMessage(apiOpts(), { messageId, body });
+          const temporaryId = generateTemporaryId();
+          // Track before editing so the edit's socket echo is recognized as ours.
+          gatewayState.sentTracker?.trackOutbound({ temporaryId, body });
+          const edited = await editMessage(apiOpts(), { messageId, body, temporaryId });
+          if (typeof edited?.id === "number") {
+            gatewayState.sentTracker?.trackId(edited.id);
+          }
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           return actionError(msg);
@@ -466,6 +475,7 @@ export const omadeusPlugin: ChannelPlugin<Account> = {
             tokenManager: gatewayState.tokenManager,
           },
           jaguarSocket: gatewayState.jaguar,
+          sentTracker: gatewayState.sentTracker ?? undefined,
         };
         return await sendOmadeusMessage(deps, { to, text });
       },
@@ -589,9 +599,13 @@ export const omadeusPlugin: ChannelPlugin<Account> = {
 
       const selfReferenceId = tokenManager.getPayload().referenceId;
 
+      const sentTracker = new SentMessageTracker();
+      gatewayState.sentTracker = sentTracker;
+
       const outboundDeps: OutboundDeps = {
         apiOpts: { maestroUrl: account.maestroUrl, tokenManager },
         jaguarSocket: null as unknown as JaguarSocketClient,
+        sentTracker,
       };
 
       const handleMessage = createOmadeusMessageHandler({
@@ -613,6 +627,23 @@ export const omadeusPlugin: ChannelPlugin<Account> = {
               : `${msg.subscribableKind}/${msg.roomName ?? msg.roomId} from ${msg.senderReferenceId}`;
           log.info(`[jaguar] ${label}: ${msg.body.slice(0, 80)}`);
 
+          // Suppress echoes of messages we sent (we send as the logged-in
+          // account, so our own messages come back over the socket). This
+          // replaces the old "drop everything from self" rule, letting the
+          // logged-in user message their own OpenClaw.
+          if (
+            sentTracker.isEcho({
+              id: msg.id,
+              temporaryId: msg.temporaryId,
+              body: msg.body,
+              roomId: msg.roomId,
+              fromSelf: msg.senderReferenceId === selfReferenceId,
+            })
+          ) {
+            log.debug?.(`[jaguar] suppressed self-echo id=${msg.id}`);
+            return;
+          }
+
           const inbound = parseJaguarMessage(msg, { selfReferenceId }, log);
           if (inbound) {
             log.info(
@@ -688,6 +719,7 @@ export const omadeusPlugin: ChannelPlugin<Account> = {
         gatewayState.tokenManager = null;
         gatewayState.jaguar = null;
         gatewayState.dolphin = null;
+        gatewayState.sentTracker = null;
         lastPersistedToken = null;
         ctx.setStatus({
           accountId: account.accountId,

package/src/inbound-policy.ts

@@ -49,7 +49,15 @@ function surfaceForKind(kind: OmadeusSubscribableKind): "direct" | "channel" | "
   return "entity";
 }
 
-function senderAllowed(allowed: number[] | undefined, fromReferenceId: number): boolean {
+function senderAllowed(
+  allowed: number[] | undefined,
+  fromReferenceId: number,
+  selfReferenceId: number,
+): boolean {
+  // The logged-in user can always reach their own instance, regardless of the
+  // configured allowlist. Their own echoes are filtered earlier by the
+  // SentMessageTracker, so this cannot create a reply loop.
+  if (fromReferenceId === selfReferenceId) return true;
   if (!allowed || allowed.length === 0) return true;
   return allowed.includes(fromReferenceId);
 }
@@ -115,7 +123,11 @@ function mentionRequired(params: {
 
 /**
  * Evaluate whether a normalized Jaguar inbound should be dispatched to OpenClaw.
- * Callers must drop self-authored messages separately if they prefer logging there.
+ *
+ * The logged-in user (`selfReferenceId`) is always treated as an allowed sender
+ * so they can message their own OpenClaw even if the stored allowlist predates
+ * them. Self-authored *echoes* (the reply loop) are filtered earlier, at socket
+ * ingestion, by the {@link SentMessageTracker} — not here.
  */
 export function evaluateOmadeusInboundPolicy(params: {
   inbound: OmadeusInboundMessage;
@@ -124,14 +136,6 @@ export function evaluateOmadeusInboundPolicy(params: {
 }): InboundPolicyDecision {
   const { inbound, omadeusCfg, selfReferenceId } = params;
 
-  if (inbound.fromReferenceId === selfReferenceId) {
-    return {
-      allow: false,
-      reason: "self_message",
-      details: { fromReferenceId: inbound.fromReferenceId, selfReferenceId },
-    };
-  }
-
   const policy = mergePolicy(omadeusCfg);
   const surface = surfaceForKind(inbound.subscribableKind);
 
@@ -139,7 +143,9 @@ export function evaluateOmadeusInboundPolicy(params: {
     if (!policy.direct.enabled) {
       return { allow: false, reason: "direct_disabled", details: { surface } };
     }
-    if (!senderAllowed(policy.direct.allowedSenderReferenceIds, inbound.fromReferenceId)) {
+    if (
+      !senderAllowed(policy.direct.allowedSenderReferenceIds, inbound.fromReferenceId, selfReferenceId)
+    ) {
       return {
         allow: false,
         reason: "direct_sender_not_allowed",
@@ -157,7 +163,9 @@ export function evaluateOmadeusInboundPolicy(params: {
     if (!policy.channels.enabled) {
       return { allow: false, reason: "channels_disabled", details: { surface } };
     }
-    if (!senderAllowed(policy.channels.allowedSenderReferenceIds, inbound.fromReferenceId)) {
+    if (
+      !senderAllowed(policy.channels.allowedSenderReferenceIds, inbound.fromReferenceId, selfReferenceId)
+    ) {
       return {
         allow: false,
         reason: "channel_sender_not_allowed",
@@ -171,6 +179,7 @@ export function evaluateOmadeusInboundPolicy(params: {
       allowedChannelViewIds: policy.channels.allowedChannelViewIds,
     });
     const senderInList =
+      inbound.fromReferenceId === selfReferenceId ||
       !policy.channels.allowedSenderReferenceIds ||
       policy.channels.allowedSenderReferenceIds.length === 0 ||
       policy.channels.allowedSenderReferenceIds.includes(inbound.fromReferenceId);
@@ -208,7 +217,9 @@ export function evaluateOmadeusInboundPolicy(params: {
       details: { kind: inbound.subscribableKind, allowedKinds: policy.entities.allowedKinds },
     };
   }
-  if (!senderAllowed(policy.entities.allowedSenderReferenceIds, inbound.fromReferenceId)) {
+  if (
+    !senderAllowed(policy.entities.allowedSenderReferenceIds, inbound.fromReferenceId, selfReferenceId)
+  ) {
     return {
       allow: false,
       reason: "entity_sender_not_allowed",

package/src/message-handler.ts

@@ -6,6 +6,7 @@ import {
   type RuntimeEnv,
 } from "../runtime-api.js";
 import { createNugget, findNuggetByTaskChannelRoom, resolveTaskChannelRoomId, searchNuggetByNumber } from "./api/nugget.api.js";
+import { seeMessage } from "./api/message.api.js";
 import {
   appendNuggetContextForTaskOrNuggetRoom,
   appendNuggetLookupContextForAgent,
@@ -68,7 +69,7 @@ export type OmadeusMessageHandlerDeps = {
   runtime: RuntimeEnv;
   log: Log;
   outboundDeps: OutboundDeps;
-  /** Authenticated Omadeus user; used to drop self-authored messages and inbound policy. */
+  /** Authenticated Omadeus user reference id. */
   selfReferenceId: number;
 };
 
@@ -82,7 +83,25 @@ export function createOmadeusMessageHandler(deps: OmadeusMessageHandlerDeps) {
     channel: "omadeus",
   });
 
-  const handleMessageNow = async (inbound: OmadeusInboundMessage) => {
+  /** Mark inbound messages as seen in Omadeus (fire-and-forget). */
+  const markMessagesSeen = (messageIds: number[]) => {
+    for (const messageId of messageIds) {
+      if (!Number.isFinite(messageId)) continue;
+      log.info(`omadeus: marking message ${messageId} seen`);
+      seeMessage(outboundDeps.apiOpts, { messageId })
+        .then(() => log.debug?.(`omadeus: marked message ${messageId} seen`))
+        .catch((err) => {
+          log.warn(
+            `omadeus: failed to mark message ${messageId} seen: ${err instanceof Error ? err.message : String(err)}`,
+          );
+        });
+    }
+  };
+
+  const handleMessageNow = async (
+    inbound: OmadeusInboundMessage,
+    ackMessageIds: number[] = [inbound.messageId],
+  ) => {
     const isDirectMessage = inbound.subscribableKind === "direct";
     const senderId = String(inbound.fromReferenceId);
     const senderName = inbound.from;
@@ -132,6 +151,12 @@ export function createOmadeusMessageHandler(deps: OmadeusMessageHandlerDeps) {
       return;
     }
 
+    // Committed to dispatching to the agent — mark the source message(s) seen.
+    // Never mark our own messages seen (the user can DM their own instance).
+    if (inbound.fromReferenceId !== selfReferenceId) {
+      markMessagesSeen(ackMessageIds);
+    }
+
     let bodyForAgent = rawBody;
     const createIntent = parseChannelTaskCreateIntent(rawBody);
     if (createIntent) {
@@ -386,11 +411,14 @@ export function createOmadeusMessageHandler(deps: OmadeusMessageHandlerDeps) {
         .join("\n");
       if (!combinedContent.trim()) return;
 
-      await handleMessageNow({
-        ...last,
-        content: combinedContent,
-        isMention: entries.some((e) => e.isMention),
-      });
+      await handleMessageNow(
+        {
+          ...last,
+          content: combinedContent,
+          isMention: entries.some((e) => e.isMention),
+        },
+        entries.map((e) => e.messageId),
+      );
     },
     onError: (err) => {
       runtime.error?.(`omadeus debounce flush failed: ${String(err)}`);

package/src/onboarding.ts

@@ -19,6 +19,7 @@ import type {
   OmadeusChannelConfig,
   OmadeusChannelView,
   OmadeusInboundEntityKind,
+  OmadeusInboundMentionPolicy,
   OmadeusOrganizationMember,
 } from "./types.js";
 import { OMADEUS_INBOUND_ENTITY_KINDS } from "./types.js";
@@ -249,36 +250,68 @@ async function promptCredentials(
   return { email, password };
 }
 
-async function promptSenderAllowlist(params: {
+/**
+ * Prompt for the set of users allowed to message this OpenClaw instance.
+ *
+ * This single allowlist governs direct messages, channels, and entity rooms.
+ * There is no "all users" option: only whitelisted members may message
+ * OpenClaw. The logged-in user is always added
+ * to the allowlist (and is excluded from the selectable list by the caller) so
+ * they can interact with their own OpenClaw. Self-authored echoes (the reply
+ * loop) are filtered earlier, at socket ingestion, by the SentMessageTracker —
+ * not by the inbound policy — so allowing yourself here cannot cause a loop.
+ */
+async function promptMessagingAllowlist(params: {
   prompter: WizardPrompter;
-  message: string;
   members: OmadeusOrganizationMember[];
+  selfReferenceId: number;
   existingReferenceIds?: number[];
-}): Promise<number[] | undefined> {
-  const { prompter, message, members, existingReferenceIds } = params;
+}): Promise<number[]> {
+  const { prompter, members, selfReferenceId, existingReferenceIds } = params;
+
+  let selected: number[] = [];
   if (members.length === 0) {
-    throw new Error("No organization members found.");
+    await prompter.note(
+      "No other organization members found. Only you will be able to message OpenClaw.",
+      "Omadeus messaging allowlist",
+    );
+  } else {
+    const memberReferenceIds = new Set(members.map((member) => member.referenceId));
+    const initialValues = (existingReferenceIds ?? [])
+      .filter((id) => id !== selfReferenceId && memberReferenceIds.has(id))
+      .map(String);
+    const chosen = await promptMultiSelect({
+      prompter,
+      message: "Which users do you want to be able to message this OpenClaw instance? (You are always allowed.)",
+      options: memberOptions(members),
+      initialValues,
+    });
+    selected = readReferenceIds(chosen);
   }
 
-  const mode = await prompter.select({
-    message,
-    options: [
-      { value: "all", label: "All users", hint: "No sender allowlist" },
-      { value: "specific", label: "Specific users", hint: "Select one or more users" },
-    ],
-    initialValue: existingReferenceIds && existingReferenceIds.length > 0 ? "specific" : "all",
-  });
-  if (mode === "all") {
-    return undefined;
-  }
+  // Always allow the logged-in user so they can message their own OpenClaw.
+  return Array.from(new Set([selfReferenceId, ...selected]));
+}
 
-  const selected = await promptMultiSelect({
-    prompter,
-    message: `${message} (specific users)`,
-    options: memberOptions(members),
-    initialValues: existingReferenceIds?.map(String),
+/**
+ * Ask whether an @mention is required to trigger OpenClaw in a given surface
+ * (channels or entity rooms). DMs never use this — you can't @mention in a DM.
+ */
+async function promptRequireMention(params: {
+  prompter: WizardPrompter;
+  surfaceLabel: string;
+  existing?: OmadeusInboundMentionPolicy;
+}): Promise<OmadeusInboundMentionPolicy> {
+  // Preserve an existing "outsideAllowlist" policy so rerunning onboarding does
+  // not force previously allowlisted users to start @mentioning OpenClaw.
+  if (params.existing === "outsideAllowlist") {
+    return "outsideAllowlist";
+  }
+  const required = await params.prompter.confirm({
+    message: `Require an @mention to trigger OpenClaw in ${params.surfaceLabel}?`,
+    initialValue: params.existing ? params.existing !== "never" : true,
   });
-  return readReferenceIds(selected);
+  return required ? "always" : "never";
 }
 
 async function promptEntityKindSelection(params: {
@@ -414,11 +447,17 @@ export const omadeusSetupWizard: ChannelSetupWizard = {
     });
     const existingInbound = section.inbound;
 
-    const directSenderIds = await promptSenderAllowlist({
+    const allowedUserReferenceIds = await promptMessagingAllowlist({
       prompter,
-      message: "Which users can DM OpenClaw directly?",
       members,
-      existingReferenceIds: existingInbound?.direct?.allowedSenderReferenceIds,
+      selfReferenceId,
+      existingReferenceIds: Array.from(
+        new Set([
+          ...(existingInbound?.direct?.allowedSenderReferenceIds ?? []),
+          ...(existingInbound?.channels?.allowedSenderReferenceIds ?? []),
+          ...(existingInbound?.entities?.allowedSenderReferenceIds ?? []),
+        ]),
+      ),
     });
 
     const selectedChannels = await promptChannelSelection({
@@ -429,30 +468,32 @@ export const omadeusSetupWizard: ChannelSetupWizard = {
       existingChannelViewIds: existingInbound?.channels?.allowedChannelViewIds,
     });
 
-    const channelSenderIds =
+    // Channels reuse the same messaging allowlist as direct messages.
+    const channelSenderIds = selectedChannels.length > 0 ? allowedUserReferenceIds : undefined;
+    const channelRequireMention =
       selectedChannels.length > 0
-        ? await promptSenderAllowlist({
+        ? await promptRequireMention({
             prompter,
-            message: "Which users can trigger OpenClaw from allowed channels?",
-            members,
-            existingReferenceIds: existingInbound?.channels?.allowedSenderReferenceIds,
+            surfaceLabel: "allowed channels",
+            existing: existingInbound?.channels?.requireMention,
           })
-        : undefined;
+        : "never";
 
     const entityKinds = await promptEntityKindSelection({
       prompter,
       existingKinds: existingInbound?.entities?.allowedKinds,
     });
 
-    const entitySenderIds =
+    // Entity rooms reuse the same messaging allowlist as direct messages.
+    const entitySenderIds = entityKinds.length > 0 ? allowedUserReferenceIds : undefined;
+    const entityRequireMention =
       entityKinds.length > 0
-        ? await promptSenderAllowlist({
+        ? await promptRequireMention({
             prompter,
-            message: "Which users can trigger OpenClaw from entity rooms?",
-            members,
-            existingReferenceIds: existingInbound?.entities?.allowedSenderReferenceIds,
+            surfaceLabel: "entity rooms",
+            existing: existingInbound?.entities?.requireMention,
           })
-        : undefined;
+        : "never";
 
     const channelRoomIds = selectedChannels
       .flatMap((selectedChannel) => [
@@ -467,20 +508,29 @@ export const omadeusSetupWizard: ChannelSetupWizard = {
 
     const senderSummary = (ids: number[] | undefined) =>
       ids && ids.length > 0 ? ids.join(", ") : "all users";
-    const entityKindSummary =
-      entityKinds.length > 0 ? entityKinds.join(", ") : "none (entity rooms disabled)";
+    const mentionSummary = (require: OmadeusInboundMentionPolicy) =>
+      require === "never"
+        ? "no @mention required"
+        : require === "outsideAllowlist"
+          ? "@mention required outside the allowlist"
+          : "@mention required";
 
     const channelSummary =
       selectedChannels.length > 0
-        ? `- Channels "${channelTitles}": rooms ${channelRoomIds.join(", ") || "(no room ids)"} from ${senderSummary(channelSenderIds)}; @mention not required in those rooms.`
+        ? `- Channels "${channelTitles}": rooms ${channelRoomIds.join(", ") || "(no room ids)"} from ${senderSummary(channelSenderIds)}; ${mentionSummary(channelRequireMention)}.`
         : "- Channels: disabled (none selected).";
 
+    const entitySummary =
+      entityKinds.length > 0
+        ? `- Entity rooms (${entityKinds.join(", ")}): ${senderSummary(entitySenderIds)}; ${mentionSummary(entityRequireMention)}.`
+        : "- Entity rooms: disabled (no room types selected).";
+
     await prompter.note(
       [
         `Inbound policy (Jaguar chat):`,
-        `- Direct messages: enabled for ${senderSummary(directSenderIds)} (no @mention required).`,
+        `- Direct messages: enabled for ${senderSummary(allowedUserReferenceIds)}.`,
         channelSummary,
-        `- Entity rooms (${entityKindSummary}): ${senderSummary(entitySenderIds)}; @mention required.`,
+        entitySummary,
       ].join("\n"),
       "Omadeus inbound policy",
     );
@@ -501,7 +551,7 @@ export const omadeusSetupWizard: ChannelSetupWizard = {
             version: 1,
             direct: {
               enabled: true,
-              ...(directSenderIds ? { allowedSenderReferenceIds: directSenderIds } : {}),
+              allowedSenderReferenceIds: allowedUserReferenceIds,
               requireMention: "never",
             },
             channels: {
@@ -509,13 +559,13 @@ export const omadeusSetupWizard: ChannelSetupWizard = {
               allowedRoomIds: channelRoomIds,
               allowedChannelViewIds: channelViewIds,
               ...(channelSenderIds ? { allowedSenderReferenceIds: channelSenderIds } : {}),
-              requireMention: "outsideAllowlist",
+              requireMention: channelRequireMention,
             },
             entities: {
               enabled: entityKinds.length > 0,
               allowedKinds: entityKinds,
               ...(entitySenderIds ? { allowedSenderReferenceIds: entitySenderIds } : {}),
-              requireMention: "always",
+              requireMention: entityRequireMention,
             },
           },
         },

package/src/outbound.ts

@@ -1,10 +1,13 @@
 import { sendRoomMessage } from "./api/message.api.js";
+import type { SentMessageTracker } from "./sent-message-tracker.js";
 import type { JaguarSocketClient } from "./socket/jaguar.socket.js";
-import type { OmadeusApiOptions } from "./utils/http.util.js";
+import { generateTemporaryId, type OmadeusApiOptions } from "./utils/http.util.js";
 
 export type OutboundDeps = {
   apiOpts: OmadeusApiOptions;
   jaguarSocket: JaguarSocketClient;
+  /** Records messages we send so their socket echoes can be suppressed. */
+  sentTracker?: SentMessageTracker;
 };
 
 export async function sendOmadeusMessage(
@@ -13,11 +16,20 @@ export async function sendOmadeusMessage(
 ): Promise<{ channel: string; messageId: string; chatId: string }> {
   const { to, text } = params;
 
-  const result = await sendRoomMessage(deps.apiOpts, { roomId: to, body: text });
+  const temporaryId = generateTemporaryId();
+  // Register before sending: the socket echo can arrive before this HTTP call
+  // returns, so the temporaryId (and body fallback) must already be tracked.
+  deps.sentTracker?.trackOutbound({ temporaryId, body: text, roomId: to });
+
+  const result = await sendRoomMessage(deps.apiOpts, { roomId: to, body: text, temporaryId });
   if (!result.ok) {
     throw new Error(`Omadeus send failed: ${result.error}`);
   }
 
+  if (typeof result.message?.id === "number") {
+    deps.sentTracker?.trackId(result.message.id);
+  }
+
   return {
     channel: "omadeus",
     messageId: String(result.message?.id ?? ""),

package/src/sent-message-tracker.ts

@@ -0,0 +1,155 @@
+/**
+ * Tracks messages this plugin sent so their Jaguar socket echoes can be
+ * suppressed, instead of dropping every message authored by the logged-in
+ * account.
+ *
+ * OpenClaw sends as the same Omadeus account it listens on, so each outbound
+ * message is broadcast back to us over the socket. We register up to three keys
+ * per send:
+ *
+ * - the client-generated `temporaryId` — known *before* the HTTP round-trip, so
+ *   it matches even when the socket echo beats the send response (the common
+ *   race);
+ * - the backend message `id` — known once the send response returns;
+ * - a normalized copy of the body scoped to its room — a last-resort fallback
+ *   used only for self-authored echoes that somehow arrive without a
+ *   recognizable id. Scoping by room prevents the same text sent in one chat
+ *   from suppressing an identical message in a different chat.
+ *
+ * `id` and `temporaryId` are kept in separate maps. Entries expire after a
+ * short TTL and each map is size-capped, so the tracker cannot grow unbounded.
+ */
+
+const DEFAULT_TTL_MS = 2 * 60 * 1000; // 2 minutes — comfortably covers echo latency.
+const DEFAULT_MAX_ENTRIES = 500;
+
+export type SentMessageTrackerOptions = {
+  ttlMs?: number;
+  maxEntries?: number;
+  now?: () => number;
+};
+
+function normalizeContent(body: string): string {
+  return body.trim();
+}
+
+/** Normalize a room identity so outbound (`"room:123"`/`"123"`) and the socket
+ * echo (numeric `123`) map to the same key. */
+function roomKey(roomId: string | number): string {
+  return String(roomId).replace(/^room:/, "").trim();
+}
+
+/** Build the room-scoped content key, or undefined when the body is empty. */
+function contentKey(roomId: string | number, body: string): string | undefined {
+  const normalized = normalizeContent(body);
+  if (!normalized) return undefined;
+  return `${roomKey(roomId)}\n${normalized}`;
+}
+
+export class SentMessageTracker {
+  private readonly ttlMs: number;
+  private readonly maxEntries: number;
+  private readonly now: () => number;
+  private readonly ids = new Map<number, number>();
+  private readonly temporaryIds = new Map<string, number>();
+  private readonly contents = new Map<string, number>();
+
+  constructor(options: SentMessageTrackerOptions = {}) {
+    this.ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+    this.maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    this.now = options.now ?? Date.now;
+  }
+
+  /** Register a client-generated temporaryId. Call before sending. */
+  trackTemporaryId(temporaryId: string): void {
+    if (!temporaryId) return;
+    this.remember(this.temporaryIds, temporaryId);
+  }
+
+  /** Register the backend message id once the send response returns. */
+  trackId(id: number): void {
+    if (!Number.isFinite(id)) return;
+    this.remember(this.ids, id);
+  }
+
+  /** Register a message body, scoped to its room, as a fallback match key. */
+  trackContent(roomId: string | number, body: string): void {
+    const key = contentKey(roomId, body);
+    if (!key) return;
+    this.remember(this.contents, key);
+  }
+
+  /** Convenience: register whichever keys are available for one outbound message. */
+  trackOutbound(params: {
+    temporaryId?: string;
+    id?: number;
+    body?: string;
+    roomId?: string | number;
+  }): void {
+    if (params.temporaryId) this.trackTemporaryId(params.temporaryId);
+    if (typeof params.id === "number") this.trackId(params.id);
+    if (typeof params.body === "string" && params.roomId !== undefined) {
+      this.trackContent(params.roomId, params.body);
+    }
+  }
+
+  /**
+   * Returns true when an inbound socket message is an echo of something we sent.
+   *
+   * `id`/`temporaryId` matches are authoritative. The content fallback only
+   * applies to self-authored messages — the only ones that can form a reply
+   * loop — and is scoped to the message's room, so a different user repeating
+   * our text (or the same text in another room) is never suppressed.
+   */
+  isEcho(msg: {
+    id?: number;
+    temporaryId?: string;
+    body?: string;
+    roomId?: string | number;
+    fromSelf: boolean;
+  }): boolean {
+    if (typeof msg.id === "number" && this.has(this.ids, msg.id)) return true;
+    if (msg.temporaryId && this.has(this.temporaryIds, msg.temporaryId)) return true;
+    if (msg.fromSelf && typeof msg.body === "string" && msg.roomId !== undefined) {
+      const key = contentKey(msg.roomId, msg.body);
+      if (key && this.has(this.contents, key)) return true;
+    }
+    return false;
+  }
+
+  private remember<K>(map: Map<K, number>, key: K): void {
+    // Delete-then-set so re-registered keys move to the end, keeping insertion
+    // order aligned with expiry order (the TTL is constant).
+    map.delete(key);
+    map.set(key, this.now() + this.ttlMs);
+    this.prune(map);
+  }
+
+  private has<K>(map: Map<K, number>, key: K): boolean {
+    const expiry = map.get(key);
+    if (expiry === undefined) return false;
+    if (expiry <= this.now()) {
+      map.delete(key);
+      return false;
+    }
+    return true;
+  }
+
+  private prune<K>(map: Map<K, number>): void {
+    const now = this.now();
+    for (const [key, expiry] of map) {
+      if (expiry <= now) {
+        map.delete(key);
+      } else {
+        // Insertion order matches expiry order, so the first live entry means
+        // everything after it is also live.
+        break;
+      }
+    }
+    while (map.size > this.maxEntries) {
+      const oldest = map.keys().next().value as K | undefined;
+      if (oldest === undefined) break;
+      map.delete(oldest);
+    }
+  }
+}