@moltzap/client 2026.726.0 → 2026.730.0

package/dist/service.js

@@ -1,26 +1,22 @@
-import { FileSystem, Path } from "@effect/platform";
-import { NodeContext } from "@effect/platform-node";
-import { AgentId as AgentIdSchema, AgentNotFoundError, AgentsList, } from "@moltzap/protocol/identity";
-import { DispatchRequest, DispatchRelease, DispatchLeaseConsumed, DispatchLeaseExpired, } from "@moltzap/protocol/message/dispatch";
-import { ConversationCreatedNotificationDefinition, ConversationArchivedNotificationDefinition, ConversationUnarchivedNotificationDefinition, ConversationList, } from "@moltzap/protocol/conversation";
-import { DEFAULT_APP_ID, TaskRequest } from "@moltzap/protocol/task";
-import { ConversationArchivedError, } from "@moltzap/protocol/conversation";
-import { MessageReceivedNotificationDefinition, MessagesList, MessagesSend, } from "@moltzap/protocol/message";
-import { NotConnectedError, RpcTimeoutError, isNotificationDeliveryFor, } from "@moltzap/protocol/rpc";
-import { AgentCallableGroup } from "@moltzap/protocol/socket/catalog";
+import { agentId as AgentIdSchema, AgentNotFoundError, agentsList, } from "@moltzap/protocol/identity";
+import { dispatchRequest, dispatchRelease, dispatchLeaseConsumed, dispatchLeaseExpired, } from "@moltzap/protocol/message/dispatch";
+import { conversationCreatedNotificationDefinition, conversationArchivedNotificationDefinition, conversationUnarchivedNotificationDefinition, conversationList, ConversationArchivedError, } from "@moltzap/protocol/conversation";
+import { DEFAULT_APP_ID, taskRequest, } from "@moltzap/protocol/task";
+import { messageReceivedNotificationDefinition, messagesList, messagesSend, } from "@moltzap/protocol/message";
+import { NotConnectedError, isNotificationDeliveryFor, } from "@moltzap/protocol/rpc";
 import { BoundedMap } from "@moltzap/protocol/bounded-map";
-import { Config, ConfigProvider, Effect, Exit, HashMap, Option, Ref, Schema, Scope, Stream, } from "effect";
+import { Effect, Exit, HashMap, Option, Ref, Schema, Scope, Stream, } from "effect";
 import { MoltZapAgentClient } from "./agent-client.js";
 import { loadServiceConfig, } from "./config.js";
 import { getOr, snapshot } from "./refs.js";
 import { getMoltZapAgentServiceSocketPath, getMoltZapServiceSocketPath, } from "./local-paths.js";
-import {} from "./local-daemon-rpc.js";
 import { makeLocalDaemonHandlers } from "./service-local-daemon.js";
 import { startLocalSocketServer, stopLocalSocketServer, } from "./local-socket-server.js";
 import { buildContextEntries, makeContextCandidate, newMessagesForConversation, notificationTraceRecord, } from "./service-helpers.js";
 import { renderPart } from "./message-rendering.js";
 import { formatHistoryMessage, lastReadIdsForSession, } from "./local-history.js";
 import { purgeAgentCacheEntries, purgeLastNotified, purgeLastRead, } from "./service-archive-purge.js";
+import { appendClientEventTrace } from "./service-event-trace.js";
 const CROSS_CONTEXT_TEXT_LIMIT = 120;
 const DEFAULT_MAX_CONTEXT_CONVERSATIONS = 5;
 const DEFAULT_MAX_MESSAGES_PER_CONVERSATION = 3;
@@ -30,25 +26,15 @@ const AGENT_LOOKUP_MAX_PAGES = 20;
 const REUSABLE_CONVERSATION_LOOKUP_PAGE_SIZE = 50;
 const REUSABLE_CONVERSATION_LOOKUP_MAX_PAGES = 20;
 const decodeAgentId = Schema.decodeUnknownOption(AgentIdSchema);
-const ClientEventLogDir = Config.option(Config.string("MOLTZAP_CLIENT_EVENT_LOG_DIR"));
-const getClientEventLogDir = () => Option.getOrUndefined(Effect.runSync(ClientEventLogDir.pipe(Effect.withConfigProvider(ConfigProvider.fromEnv()))));
-function appendClientEventTrace(record) {
-    const dir = getClientEventLogDir();
-    if (!dir)
-        return Effect.void;
-    return Effect.gen(function* () {
-        const fileSystem = yield* FileSystem.FileSystem;
-        const path = yield* Path.Path;
-        const agentId = typeof record["agentId"] === "string" ? record["agentId"] : "unknown";
-        const safeAgentId = /^[A-Za-z0-9_-]+$/.test(agentId) ? agentId : "unknown";
-        yield* Effect.zipRight(fileSystem.makeDirectory(dir, { recursive: true }), fileSystem.writeFileString(path.join(dir, `client-events-${safeAgentId}.jsonl`), JSON.stringify(record) + "\n", { flag: "a" }));
-    }).pipe(Effect.withSpan("appendClientEventTrace"), Effect.provide(NodeContext.layer), Effect.catchAll((err) => Effect.logWarning("moltzap client event trace write failed", err)));
-}
 const agentNotFound = (agentName) => new AgentNotFoundError({
     message: `Agent not found: ${agentName}`,
     data: { agentName },
 });
-/** Escape `<`, `>`, `&` so sender content can't escape a `<system-reminder>` block. */
+/**
+ * Escape `<`, `>`, `&` so sender content can't escape a `<system-reminder>` block.
+ * @param s Value supplied to the operation.
+ * @returns The sanitize for system reminder result.
+ */
 export function sanitizeForSystemReminder(s) {
     return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
@@ -56,10 +42,15 @@ export function sanitizeForSystemReminder(s) {
  * Format CrossConversationEntry[] as a `&lt;system-reminder>` block. Adapters
  * that inline context into prompt text (nanoclaw) and `MoltZapService.getContext`
  * share this formatter so sanitization and line shape stay in one place.
+ * @param entries Value supplied to the operation.
+ * @param opts Value supplied to the operation.
+ * @param opts.header Value supplied to the operation.
+ * @returns The format cross conversation block result.
  */
 function formatCrossConversationBlock(entries, opts) {
-    if (entries.length === 0)
+    if (entries.length === 0) {
         return null;
+    }
     const lines = entries.map((e) => {
         const safeSender = sanitizeForSystemReminder(e.senderName);
         const safeText = sanitizeForSystemReminder(e.text.slice(0, CROSS_CONTEXT_TEXT_LIMIT));
@@ -88,6 +79,8 @@ const DEDUP_WINDOW_PER_CONV = 1000;
 /**
  * Invoke every handler with `arg`, isolating throws so one bad handler
  * doesn't abort the remaining fanout.
+ * @param handlers Value supplied to the operation.
+ * @param arg Value supplied to the operation.
  */
 function fanout(handlers, arg) {
     for (const h of handlers) {
@@ -109,9 +102,8 @@ function fanout(handlers, arg) {
  * callers compose failures and cancellation explicitly.
  */
 export class MoltZapService {
-    opts;
     client = null;
-    _connected = false;
+    connectedValue = false;
     /**
      * Service-owned scope. Opened in `connect()`, owns the
      * `subscribeAll → Stream.runForEach` fan-out fiber. Closed in `close()` so
@@ -137,25 +129,25 @@ export class MoltZapService {
         message: [],
         rawNotification: [],
         disconnect: [],
-        reconnect: [],
         conversationArchived: [],
         conversationUnarchived: [],
         dispatchRelease: [],
         dispatchLeaseConsumed: [],
         dispatchLeaseExpired: [],
     };
-    _ownAgentId;
+    ownAgentIdValue;
+    opts;
     constructor(opts) {
         this.opts = opts;
         // The empty HelloOk carries no identity; `ownAgentId` is the client's
         // registered/stored id, available before the handshake.
-        this._ownAgentId = opts.agentId;
+        this.ownAgentIdValue = opts.agentId;
     }
     static fromConfig(config) {
         return new MoltZapService(config);
     }
     static make(profileName) {
-        return loadServiceConfig(profileName).pipe(Effect.map(MoltZapService.fromConfig));
+        return loadServiceConfig(profileName).pipe(Effect.map((config) => MoltZapService.fromConfig(config)));
     }
     static startDaemon(profileName) {
         return Effect.gen(function* () {
@@ -166,12 +158,15 @@ export class MoltZapService {
         }).pipe(Effect.withSpan("MoltZapService.startDaemon"));
     }
     get connected() {
-        return this._connected;
+        return this.connectedValue;
     }
     get ownAgentId() {
-        return this._ownAgentId;
+        return this.ownAgentIdValue;
     }
-    /** Effect-native: compose via `yield*` or bridge at the edge via `Effect.runPromise`. */
+    /**
+     * Effect-native: compose via `yield*` or bridge at the edge via `Effect.runPromise`.
+     * @returns The client result.
+     */
     connect() {
         return Effect.gen(this, function* () {
             const client = new MoltZapAgentClient({
@@ -181,13 +176,9 @@ export class MoltZapService {
                 // kept explicit so a future disconnect-handler chain can plumb
                 // code/reason through.
                 onDisconnect: () => {
-                    this._connected = false;
+                    this.connectedValue = false;
                     fanout(this.handlers.disconnect, undefined);
                 },
-                onReconnect: (helloOk) => {
-                    this._connected = true;
-                    fanout(this.handlers.reconnect, helloOk);
-                },
             });
             this.client = client;
             // `subscribeAll().pipe(Stream.runForEach, …)` is forked into a
@@ -202,10 +193,12 @@ export class MoltZapService {
             // before the fiber exits.
             const serviceScope = yield* Scope.make();
             this.serviceScope = serviceScope;
-            const fanoutEffect = client.subscribeAll().pipe(Stream.runForEach((notification) => Effect.sync(() => this.handleNotification(notification))), Effect.catchAll((cause) => Effect.logWarning("MoltZapService notification fan-out terminated", cause)), Effect.asVoid);
+            const fanoutEffect = client.subscribeAll().pipe(Stream.runForEach((notification) => Effect.sync(() => {
+                this.handleNotification(notification);
+            })), Effect.catchAll((cause) => Effect.logWarning("MoltZapService notification fan-out terminated", cause)), Effect.asVoid);
             yield* Effect.forkIn(fanoutEffect, serviceScope);
             const helloOk = yield* client.connect();
-            this._connected = true;
+            this.connectedValue = true;
             return helloOk;
         });
     }
@@ -216,7 +209,7 @@ export class MoltZapService {
      * shutdown.
      */
     close() {
-        this._connected = false;
+        this.connectedValue = false;
         Effect.runFork(this.stopSocketServer());
         const scopeToClose = this.serviceScope;
         const clientToClose = this.client;
@@ -237,10 +230,9 @@ export class MoltZapService {
         ]));
         this.archivedConversationIds.clear();
         this.seenMessageIds.clear();
-        // Handlers are preserved across close()/connect() cycles. MoltZapChannelCore
-        // subscribes once in its constructor; clearing handlers here would silently
-        // drop inbound/reconnect dispatch on any subsequent reconnect of the same
-        // service instance.
+        // Handlers are preserved across explicit close()/connect() cycles.
+        // MoltZapChannelCore subscribes once in its constructor; clearing handlers
+        // here would silently drop inbound dispatch after the next connect.
     }
     // --- Socket Server ---
     socketServerScope = null;
@@ -252,11 +244,16 @@ export class MoltZapService {
      * compromised or malicious server returns an id containing `..` or a
      * path separator, a naive `path.join(... , agentId)` escapes `~/.moltzap`.
      * Reject anything that isn't a safe identifier.
+     * @param id Value supplied to the operation.
+     * @returns The id result.
      */
     static safeAgentIdSegment(id) {
         return /^[A-Za-z0-9_-]+$/.test(id) ? id : "default";
     }
-    /** Per-instance socket path based on connected agentId. */
+    /**
+     * Per-instance socket path based on connected agentId.
+     * @returns The id result.
+     */
     get socketPath() {
         const id = MoltZapService.safeAgentIdSegment(this.ownAgentId ?? "default");
         return getMoltZapAgentServiceSocketPath(id);
@@ -295,8 +292,8 @@ export class MoltZapService {
     }
     localDaemonHandlers() {
         return makeLocalDaemonHandlers({
-            ownAgentId: this._ownAgentId,
-            connected: this._connected,
+            ownAgentId: this.ownAgentIdValue,
+            connected: this.connectedValue,
             conversationCount: () => this.getConversations().length,
             call: this.call.bind(this),
             handleHistoryRequest: (request) => this.handleHistoryRequest(request),
@@ -304,7 +301,7 @@ export class MoltZapService {
     }
     handleHistoryRequest(request) {
         return Effect.gen(this, function* () {
-            const result = yield* this.call(MessagesList.name, {
+            const result = yield* this.call(messagesList.name, {
                 taskId: request.taskId,
                 conversationId: request.conversationId,
                 limit: request.limit,
@@ -344,15 +341,16 @@ export class MoltZapService {
             const unknownAgentIds = [
                 ...new Set(messages.map((message) => message.senderId)),
             ].filter((id) => !HashMap.has(knownNames, id));
-            if (unknownAgentIds.length === 0)
+            if (unknownAgentIds.length === 0) {
                 return;
+            }
             yield* this.cacheVisibleAgentNamesForIds(new Set(unknownAgentIds)).pipe(Effect.asVoid, Effect.catchAll(() => Effect.void));
         });
     }
     fetchHistoryConversationMeta(convId) {
         // The client filters `ConversationList` output for the matching
         // conversation id (there is no per-conversation get RPC).
-        return this.call(ConversationList.name, {}).pipe(Effect.map((result) => {
+        return this.call(conversationList.name, {}).pipe(Effect.map((result) => {
             const hit = result.items.find((item) => item.conversation.id === convId);
             return hit?.conversation;
         }), Effect.catchAll(() => Effect.succeed(undefined)));
@@ -364,9 +362,11 @@ export class MoltZapService {
         const { conversationId, sessionKey } = request;
         return Ref.update(this.lastReadRef, (outer) => {
             const perSession = getOr(outer, sessionKey, () => HashMap.empty());
-            const existing = getOr(perSession, conversationId, () => new Set());
-            if (messages.every((message) => existing.has(message.id)))
+            const existing = getOr(perSession, conversationId, () => 
+            /* Safe because the surrounding invariant establishes this asserted shape. */ new Set());
+            if (messages.every((message) => existing.has(message.id))) {
                 return outer;
+            }
             const nextSet = new Set(existing);
             for (const message of messages) {
                 nextSet.add(message.id);
@@ -398,15 +398,19 @@ export class MoltZapService {
      * when the RPC errors or the server has no record. The error path logs
      * so ops can see repeated lookup failures; the empty-response path is
      * silent (a cold agent is an expected transient state).
+     * @param agentId Identifier of the agent targeted by the operation.
+     * @returns The decoded d agent id.
      */
     resolveAgentName(agentId) {
         return Effect.gen(this, function* () {
             const decodedAgentId = Option.getOrUndefined(decodeAgentId(agentId));
-            if (decodedAgentId === undefined)
+            if (decodedAgentId === undefined) {
                 return agentId;
+            }
             const cached = Option.getOrUndefined(HashMap.get(snapshot(this.agentNamesRef), agentId));
-            if (cached !== undefined)
+            if (cached !== undefined) {
                 return cached;
+            }
             return yield* this.cacheVisibleAgentNamesForIds(new Set([decodedAgentId])).pipe(Effect.map(() => {
                 const resolved = Option.getOrUndefined(HashMap.get(snapshot(this.agentNamesRef), agentId));
                 return resolved ?? agentId;
@@ -443,12 +447,19 @@ export class MoltZapService {
      * params frame. The server marks the lease consumed, blocking the
      * app authorization timeout sweep. `MoltZapChannelCore.sendReply` forwards
      * `leaseIdInFlight` automatically when the caller omits it.
+     * @param taskId Value supplied to the operation.
+     * @param conversationId Value supplied to the operation.
+     * @param text Text to process.
+     * @param opts Value supplied to the operation.
+     * @param opts.replyTo Value supplied to the operation.
+     * @param opts.dispatchLeaseId Value supplied to the operation.
+     * @returns The send result.
      */
     send(taskId, conversationId, text, opts) {
         if (this.isConversationArchived(conversationId)) {
             return Effect.fail(new ConversationArchivedError({ message: "Conversation is archived" }));
         }
-        return Effect.asVoid(this.call(MessagesSend.name, {
+        return Effect.asVoid(this.call(messagesSend.name, {
             taskId,
             conversationId,
             parts: [{ type: "text", text }],
@@ -462,9 +473,11 @@ export class MoltZapService {
      * Issue `agent/dispatch/request`. The server returns the ack
      * `{leaseId, dispatchId}` immediately; the recipient observes the
      * verdict asynchronously via the `dispatchRelease` event.
+     * @param params Request payload to process.
+     * @returns The cache result.
      */
     requestDispatch(params) {
-        return this.call(DispatchRequest.name, params);
+        return this.call(dispatchRequest.name, params);
     }
     sendToAgent(agentName, text, opts) {
         return Effect.gen(this, function* () {
@@ -475,7 +488,7 @@ export class MoltZapService {
                 if (!agent) {
                     return yield* Effect.fail(agentNotFound(agentName));
                 }
-                const createResult = yield* this.call(TaskRequest.name, {
+                const createResult = yield* this.call(taskRequest.name, {
                     appId: DEFAULT_APP_ID,
                     invitedAgentIds: [agent.id],
                     initialConversation: { participants: [agent.id] },
@@ -501,23 +514,27 @@ export class MoltZapService {
                 const params = {
                     limit: REUSABLE_CONVERSATION_LOOKUP_PAGE_SIZE,
                 };
-                if (cursor !== undefined)
+                if (cursor !== undefined) {
                     params.cursor = cursor;
-                const result = yield* this.call(ConversationList.name, params);
+                }
+                const result = yield* this.call(conversationList.name, params);
                 const hit = result.items.find((item) => item.taskId === taskId &&
                     item.conversation.archivedAt === undefined);
-                if (hit !== undefined)
+                if (hit !== undefined) {
                     return hit.conversation.id;
-                if (result.nextCursor === undefined)
+                }
+                if (result.nextCursor === undefined) {
                     break;
+                }
                 cursor = result.nextCursor;
             }
             return yield* Effect.fail(agentNotFound(agentName));
         });
     }
     cacheAgentNames(agents) {
-        if (agents.length === 0)
+        if (agents.length === 0) {
             return Effect.void;
+        }
         return Ref.update(this.agentNamesRef, (names) => {
             let next = names;
             for (const agent of agents) {
@@ -537,12 +554,14 @@ export class MoltZapService {
             let cursor = undefined;
             for (let page = 0; page < AGENT_LOOKUP_MAX_PAGES; page++) {
                 const params = this.agentListParams(cursor);
-                const result = yield* this.call(AgentsList.name, params);
+                const result = yield* this.call(agentsList.name, params);
                 yield* this.cacheAgentNames(result.agents);
-                for (const agent of result.agents)
+                for (const agent of result.agents) {
                     missing.delete(agent.id);
-                if (missing.size === 0 || result.nextCursor === undefined)
+                }
+                if (missing.size === 0 || result.nextCursor === undefined) {
                     return;
+                }
                 cursor = result.nextCursor;
             }
         });
@@ -552,11 +571,12 @@ export class MoltZapService {
             let cursor = undefined;
             for (let page = 0; page < AGENT_LOOKUP_MAX_PAGES; page++) {
                 const params = this.agentListParams(cursor);
-                const result = yield* this.call(AgentsList.name, params);
+                const result = yield* this.call(agentsList.name, params);
                 yield* this.cacheAgentNames(result.agents);
                 const hit = result.agents.find((agent) => agent.name === agentName);
-                if (hit !== undefined || result.nextCursor === undefined)
+                if (hit !== undefined || result.nextCursor === undefined) {
                     return hit;
+                }
                 cursor = result.nextCursor;
             }
             return undefined;
@@ -567,12 +587,16 @@ export class MoltZapService {
      * Generate a system reminder with updates from other conversations.
      * Each conversation has its own view of what's "new" — markers are tracked
      * per viewing conversation and advanced after notification.
+     * @param currentConvId Value supplied to the operation.
+     * @param opts Value supplied to the operation.
+     * @returns The context options result.
      */
     getContext(currentConvId, opts) {
         const contextOptions = opts ?? {};
         const { entries, commit } = this.peekContextEntries(currentConvId, contextOptions);
-        if (entries.length === 0)
+        if (entries.length === 0) {
             return null;
+        }
         commit();
         return formatCrossConversationBlock(entries, {
             header: `Recent updates (you are in conv:${currentConvId}):`,
@@ -583,6 +607,11 @@ export class MoltZapService {
      * Call `commit()` on the result to mark the returned messages as seen so
      * subsequent peeks return only what's new. A caller that reads without
      * committing can re-peek idempotently.
+     * @param currentConvId Value supplied to the operation.
+     * @param opts Value supplied to the operation.
+     * @param opts.maxConversations Value supplied to the operation.
+     * @param opts.maxMessagesPerConv Value supplied to the operation.
+     * @returns The max convs result.
      */
     peekContextEntries(currentConvId, opts) {
         const maxConvs = opts?.maxConversations ?? DEFAULT_MAX_CONTEXT_CONVERSATIONS;
@@ -592,13 +621,17 @@ export class MoltZapService {
         const { entries, pendingAdvances } = buildContextEntries(candidates.slice(0, maxConvs), state, maxMsgsPerConv);
         return {
             entries,
-            commit: () => this.advanceLastNotified(currentConvId, pendingAdvances),
+            commit: () => {
+                this.advanceLastNotified(currentConvId, pendingAdvances);
+            },
         };
     }
     /**
      * Return all new messages from all other conversations as full transcripts,
      * sorted chronologically. Uses the same lastNotified markers as
      * peekContextEntries. Call commit() to advance markers.
+     * @param currentConvId Value supplied to the operation.
+     * @returns The all messages result.
      */
     peekFullMessages(currentConvId) {
         const { messagesMap, conversationsMap, agentNamesMap, viewMarkers } = this.readCrossConvState(currentConvId);
@@ -616,12 +649,17 @@ export class MoltZapService {
                     timestamp: m.createdAt,
                 });
             }
-            pendingAdvances.push([convId, newMsgs[newMsgs.length - 1].id]);
+            pendingAdvances.push([
+                convId,
+                /* Safe because the surrounding invariant establishes this asserted shape. */ newMsgs[newMsgs.length - 1].id,
+            ]);
         }
         allMessages.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
         return {
             messages: allMessages,
-            commit: () => this.advanceLastNotified(currentConvId, pendingAdvances),
+            commit: () => {
+                this.advanceLastNotified(currentConvId, pendingAdvances);
+            },
         };
     }
     readCrossConvState(currentConvId) {
@@ -644,13 +682,15 @@ export class MoltZapService {
     *iterNewMessagesByConv(messagesMap, viewMarkers, currentConvId) {
         for (const [convId, msgs] of messagesMap) {
             const newMsgs = newMessagesForConversation(convId, msgs, viewMarkers, currentConvId);
-            if (newMsgs.length > 0)
+            if (newMsgs.length > 0) {
                 yield [convId, newMsgs];
+            }
         }
     }
     advanceLastNotified(currentConvId, pendingAdvances) {
-        if (pendingAdvances.length === 0)
+        if (pendingAdvances.length === 0) {
             return;
+        }
         Effect.runSync(Ref.update(this.lastNotifiedRef, (outer) => {
             let markers = getOr(outer, currentConvId, () => HashMap.empty());
             for (const [convId, msgId] of pendingAdvances) {
@@ -668,6 +708,10 @@ export class MoltZapService {
      * Outbound RPC, typed per method — delegates to the agent client's typed
      * `call`. `call("agent/identity/agents/list", payload)` recovers the result and that
      * method's tagged-error union; an app-only method does not typecheck.
+     * @param tag Value supplied to the operation.
+     * @param payload Value supplied to the operation.
+     * @param opts Value supplied to the operation.
+     * @returns The client result.
      */
     call(tag, payload, opts) {
         return Effect.suspend(() => {
@@ -694,47 +738,49 @@ export class MoltZapService {
         this.dispatchTypedNotification(notification);
     }
     recordNotificationTrace(notification) {
-        Effect.runFork(appendClientEventTrace(notificationTraceRecord(notification, this._ownAgentId)));
+        Effect.runFork(appendClientEventTrace(notificationTraceRecord(notification, this.ownAgentIdValue)));
     }
     dispatchTypedNotification(notification) {
-        if (this.dispatchMessageNotification(notification))
+        if (this.dispatchMessageNotification(notification)) {
             return;
-        if (this.dispatchConversationNotification(notification))
+        }
+        if (this.dispatchConversationNotification(notification)) {
             return;
+        }
         this.dispatchAppNotification(notification);
     }
     dispatchMessageNotification(notification) {
-        if (isNotificationDeliveryFor(notification, MessageReceivedNotificationDefinition)) {
+        if (isNotificationDeliveryFor(notification, messageReceivedNotificationDefinition)) {
             this.handleMessageReceivedNotification(notification.params);
             return true;
         }
         return false;
     }
     dispatchConversationNotification(notification) {
-        if (isNotificationDeliveryFor(notification, ConversationCreatedNotificationDefinition)) {
+        if (isNotificationDeliveryFor(notification, conversationCreatedNotificationDefinition)) {
             this.handleConversationCreatedNotification(notification.params);
             return true;
         }
-        if (isNotificationDeliveryFor(notification, ConversationArchivedNotificationDefinition)) {
+        if (isNotificationDeliveryFor(notification, conversationArchivedNotificationDefinition)) {
             this.handleConversationArchivedNotification(notification.params);
             return true;
         }
-        if (isNotificationDeliveryFor(notification, ConversationUnarchivedNotificationDefinition)) {
+        if (isNotificationDeliveryFor(notification, conversationUnarchivedNotificationDefinition)) {
             this.handleConversationUnarchivedNotification(notification.params);
             return true;
         }
         return false;
     }
     dispatchAppNotification(notification) {
-        if (isNotificationDeliveryFor(notification, DispatchRelease)) {
+        if (isNotificationDeliveryFor(notification, dispatchRelease)) {
             fanout(this.handlers.dispatchRelease, notification.params);
             return;
         }
-        if (isNotificationDeliveryFor(notification, DispatchLeaseConsumed)) {
+        if (isNotificationDeliveryFor(notification, dispatchLeaseConsumed)) {
             fanout(this.handlers.dispatchLeaseConsumed, notification.params);
             return;
         }
-        if (isNotificationDeliveryFor(notification, DispatchLeaseExpired)) {
+        if (isNotificationDeliveryFor(notification, dispatchLeaseExpired)) {
             fanout(this.handlers.dispatchLeaseExpired, notification.params);
         }
     }
@@ -749,6 +795,9 @@ export class MoltZapService {
      * replay, dual subscription) is suppressed to one
      * `on("message", ...)` event. `agent/message/list` returns raw history
      * unfiltered; consumers that combine both feeds dedup themselves.
+     * @param convId Value supplied to the operation.
+     * @param msgId Value supplied to the operation.
+     * @returns The dedup window result.
      */
     recordMessageIdIfNew(convId, msgId) {
         let dedupWindow = this.seenMessageIds.get(convId);
@@ -774,7 +823,7 @@ export class MoltZapService {
         // Name resolution is driven lazily by channel-core's serialized consumer
         // via resolveAgentName(), which populates agentNamesRef on first miss and
         // hits the cache on every subsequent message.
-        if (msg.senderId !== this._ownAgentId) {
+        if (msg.senderId !== this.ownAgentIdValue) {
             fanout(this.handlers.message, {
                 taskId: notification.taskId,
                 message: msg,