@brantrusnak/openclaw-omadeus 1.0.4 → 1.0.6

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/dist/src/setup-core.js

@@ -1,3 +1,4 @@
+import { resolveOmadeusEnvironment } from "./defaults.js";
 //#region src/setup-core.ts
 function readSetupStringField(input, key) {
 	const value = input[key];
@@ -18,8 +19,8 @@ const omadeusSetupAdapter = {
 	},
 	applyAccountConfig: ({ cfg, input }) => {
 		const rawInput = input;
-		const casUrl = input.httpUrl?.trim() || void 0;
-		const maestroUrl = input.url?.trim() || void 0;
+		const environmentRaw = readSetupStringField(rawInput, "environment");
+		const environment = environmentRaw ? resolveOmadeusEnvironment(environmentRaw) : void 0;
 		const email = readSetupStringField(rawInput, "email");
 		const password = input.password?.trim() || void 0;
 		const organizationId = readSetupNumberField(rawInput, "organizationId");
@@ -32,8 +33,7 @@ const omadeusSetupAdapter = {
 				omadeus: {
 					...omadeusPrevious,
 					enabled: true,
-					...casUrl ? { casUrl } : {},
-					...maestroUrl ? { maestroUrl } : {},
+					...environment ? { environment } : {},
 					...email ? { email } : {},
 					...password ? { password } : {},
 					...organizationId ? { organizationId } : {}

package/openclaw.plugin.json

@@ -6,12 +6,18 @@
     "additionalProperties": false,
     "properties": {
       "enabled": { "type": "boolean" },
-      "casUrl": { "type": "string" },
-      "maestroUrl": { "type": "string" },
+      "environment": {
+        "type": "string",
+        "enum": ["production", "staging", "dev"]
+      },
       "email": { "type": "string" },
       "password": { "type": "string" },
       "organizationId": { "type": "number" },
       "sessionToken": { "type": "string" },
+      "sessionTokenEnvironment": {
+        "type": "string",
+        "enum": ["production", "staging", "dev"]
+      },
       "inbound": {
         "type": "object",
         "additionalProperties": false,
@@ -92,12 +98,18 @@
         "additionalProperties": false,
         "properties": {
           "enabled": { "type": "boolean" },
-          "casUrl": { "type": "string" },
-          "maestroUrl": { "type": "string" },
+          "environment": {
+            "type": "string",
+            "enum": ["production", "staging", "dev"]
+          },
           "email": { "type": "string" },
           "password": { "type": "string" },
           "organizationId": { "type": "number" },
           "sessionToken": { "type": "string" },
+          "sessionTokenEnvironment": {
+            "type": "string",
+            "enum": ["production", "staging", "dev"]
+          },
           "inbound": {
             "type": "object",
             "additionalProperties": false,
@@ -172,13 +184,8 @@
         }
       },
       "uiHints": {
-        "casUrl": {
-          "label": "CAS URL",
-          "placeholder": "https://dev1-cas.rouztech.com"
-        },
-        "maestroUrl": {
-          "label": "Maestro URL",
-          "placeholder": "https://dev3-maestro.rouztech.com"
+        "environment": {
+          "label": "Environment"
         },
         "email": {
           "label": "Email"
@@ -195,6 +202,10 @@
           "sensitive": true,
           "advanced": true
         },
+        "sessionTokenEnvironment": {
+          "label": "Session token environment",
+          "advanced": true
+        },
         "inbound": {
           "label": "Inbound policy (Jaguar chat)",
           "advanced": true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brantrusnak/openclaw-omadeus",
-  "version": "1.0.4",
+  "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,18 +53,22 @@ 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";
 
 let lastPersistedToken: string | null = null;
 
-async function persistSessionToken(token: string): Promise<void> {
+async function persistSessionToken(
+  token: string,
+  environment: Account["environment"],
+): Promise<void> {
   if (lastPersistedToken === token) return;
   const runtime = getOmadeusRuntime();
   const cfg = runtime.config.current() as OpenClawConfig;
   const section = getOmadeusChannelConfig(cfg) ?? {};
-  if (section.sessionToken === token) {
+  if (section.sessionToken === token && section.sessionTokenEnvironment === environment) {
     lastPersistedToken = token;
     return;
   }
@@ -74,6 +80,7 @@ async function persistSessionToken(token: string): Promise<void> {
         omadeus: {
           ...(getOmadeusChannelConfig(draft) ?? {}),
           sessionToken: token,
+          sessionTokenEnvironment: environment,
         },
       };
     },
@@ -103,12 +110,12 @@ const omadeusConfigAdapter = createTopLevelChannelConfigAdapter<Account>({
   defaultAccountId: resolveDefaultOmadeusAccountId,
   deleteMode: "clear-fields",
   clearBaseFields: [
-    "casUrl",
-    "maestroUrl",
+    "environment",
     "email",
     "password",
     "organizationId",
     "sessionToken",
+    "sessionTokenEnvironment",
     "inbound",
   ],
   // Keep adapter contract satisfied even though Omadeus no longer uses DM allowlists.
@@ -315,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);
@@ -462,6 +475,7 @@ export const omadeusPlugin: ChannelPlugin<Account> = {
             tokenManager: gatewayState.tokenManager,
           },
           jaguarSocket: gatewayState.jaguar,
+          sentTracker: gatewayState.sentTracker ?? undefined,
         };
         return await sendOmadeusMessage(deps, { to, text });
       },
@@ -561,7 +575,7 @@ export const omadeusPlugin: ChannelPlugin<Account> = {
         initialToken: account.sessionToken,
         onRefresh: (token) => {
           log.info("[omadeus] token refreshed");
-          void persistSessionToken(token).catch((err) =>
+          void persistSessionToken(token, account.environment).catch((err) =>
             log.warn(`[omadeus] failed to persist session token: ${String(err)}`),
           );
         },
@@ -585,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({
@@ -609,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(
@@ -684,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/config.ts

@@ -1,5 +1,8 @@
 import { DEFAULT_ACCOUNT_ID, type OpenClawConfig } from "../runtime-api.js";
-import { OMADEUS_CAS_URL, OMADEUS_MAESTRO_URL } from "./defaults.js";
+import {
+  getOmadeusEnvironmentUrls,
+  resolveOmadeusEnvironment,
+} from "./defaults.js";
 import type { OmadeusChannelConfig, ResolvedOmadeusAccount } from "./types.js";
 
 export function getOmadeusChannelConfig(cfg: OpenClawConfig): OmadeusChannelConfig | undefined {
@@ -24,11 +27,17 @@ export function resolveOmadeusAccount(params: {
 }): ResolvedOmadeusAccount {
   const { cfg } = params;
   const section = getOmadeusChannelConfig(cfg) ?? {};
+  const environment = resolveOmadeusEnvironment(section.environment);
+  const { casUrl, maestroUrl } = getOmadeusEnvironmentUrls(environment);
   const envCredentials = resolveOmadeusEnvCredentials();
   const email = section.email?.trim() || envCredentials?.email || "";
   const password = section.password?.trim() || envCredentials?.password || "";
   const orgId = section.organizationId ?? envCredentials?.organizationId;
-  const sessionToken = section.sessionToken?.trim() ?? "";
+  const rawSessionToken = section.sessionToken?.trim() ?? "";
+  const sessionTokenEnvironment = resolveOmadeusEnvironment(section.sessionTokenEnvironment);
+  const sessionTokenValid =
+    Boolean(rawSessionToken) && sessionTokenEnvironment === environment;
+  const sessionToken = sessionTokenValid ? rawSessionToken : "";
   const hasCredentials = Boolean(email && password && orgId);
   const hasSessionToken = Boolean(sessionToken);
   const hasConfigCredentials = Boolean(
@@ -47,8 +56,9 @@ export function resolveOmadeusAccount(params: {
     name: "Omadeus",
     enabled: section.enabled !== false,
     config: section,
-    casUrl: section.casUrl?.trim() || OMADEUS_CAS_URL,
-    maestroUrl: section.maestroUrl?.trim() || OMADEUS_MAESTRO_URL,
+    environment,
+    casUrl,
+    maestroUrl,
     email,
     password,
     organizationId: orgId ?? 0,

package/src/defaults.ts

@@ -1,2 +1,44 @@
-export const OMADEUS_CAS_URL = "https://dev1-cas.rouztech.com";
-export const OMADEUS_MAESTRO_URL = "https://dev3-maestro.rouztech.com";
+export type OmadeusEnvironment = "production" | "staging" | "dev";
+
+export const OMADEUS_DEFAULT_ENVIRONMENT: OmadeusEnvironment = "dev";
+
+export type OmadeusEnvironmentConfig = {
+  label: string;
+  casUrl: string;
+  maestroUrl: string;
+};
+
+export const OMADEUS_ENVIRONMENTS: Record<OmadeusEnvironment, OmadeusEnvironmentConfig> = {
+  production: {
+    label: "Production",
+    casUrl: "https://xas.xeba.tech",
+    maestroUrl: "https://maestro.xeba.tech",
+  },
+  staging: {
+    label: "Staging",
+    casUrl: "https://staging-xas.xeba.tech",
+    maestroUrl: "https://staging.xeba.tech",
+  },
+  dev: {
+    label: "Dev",
+    casUrl: "https://dev1-cas.rouztech.com",
+    maestroUrl: "https://dev1-maestro.rouztech.com",
+  },
+};
+
+const OMADEUS_ENVIRONMENT_SET = new Set<string>(Object.keys(OMADEUS_ENVIRONMENTS));
+
+export function resolveOmadeusEnvironment(value: unknown): OmadeusEnvironment {
+  if (typeof value === "string" && OMADEUS_ENVIRONMENT_SET.has(value)) {
+    return value as OmadeusEnvironment;
+  }
+  return OMADEUS_DEFAULT_ENVIRONMENT;
+}
+
+export function getOmadeusEnvironmentUrls(env: OmadeusEnvironment): {
+  casUrl: string;
+  maestroUrl: string;
+} {
+  const config = OMADEUS_ENVIRONMENTS[env];
+  return { casUrl: config.casUrl, maestroUrl: config.maestroUrl };
+}

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)}`);