@moltzap/client 2026.528.0 → 2026.717.0

package/dist/service.js

@@ -1,24 +1,34 @@
-/* eslint-disable jsdoc/text-escaping -- mermaid sequenceDiagram blocks need literal `<br>` (HTML5) for renderer compatibility; the escape would render as literal text. */
 import { FileSystem, Path } from "@effect/platform";
 import { NodeContext } from "@effect/platform-node";
-import { AgentsLookup, AgentsLookupByName, DispatchRequest, DispatchRelease, DispatchesConsumed, DispatchesExpired, DispatchesGet, MessageReceivedNotificationDefinition, TaskConversationCreatedNotificationDefinition, TaskConversationArchivedNotificationDefinition, TaskConversationUnarchivedNotificationDefinition, ConversationArchivedError, DEFAULT_APP_ID, MessagesList, MessagesSend, TaskRequest, TaskConversationList, NotConnectedError, serverRpcMethods, RpcServerError, RpcTimeoutError, } from "@moltzap/protocol";
-import { Config, ConfigProvider, Effect, HashMap, Option, Ref, Scope, Stream, } from "effect";
+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 { Config, ConfigProvider, Effect, Exit, HashMap, Option, Ref, Schema, Scope, Stream, } from "effect";
 import { MoltZapAgentClient } from "./agent-client.js";
-import { AgentNotFoundError } from "./runtime/errors.js";
-import { getOr, snapshot } from "./runtime/refs.js";
-import { LocalServiceCommands } from "./runtime/local-service-commands.js";
+import { loadServiceConfig, } from "./config.js";
+import { getOr, snapshot } from "./refs.js";
 import { getMoltZapAgentServiceSocketPath, getMoltZapServiceSocketPath, } from "./local-paths.js";
-import { startLocalSocketServer, stopLocalSocketServer, } from "./runtime/local-socket-server.js";
-import { buildContextEntries, makeContextCandidate, newMessagesForConversation, notificationTraceRecord, renderPart, ServiceInputError, } from "./runtime/service-helpers.js";
-import { decodeHistoryRequest, formatHistoryMessage, lastReadIdsForSession, } from "./runtime/local-history.js";
-import { composeServiceTeardown } from "./runtime/service-teardown.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";
 const CROSS_CONTEXT_TEXT_LIMIT = 120;
 const DEFAULT_MAX_CONTEXT_CONVERSATIONS = 5;
 const DEFAULT_MAX_MESSAGES_PER_CONVERSATION = 3;
 const HISTORY_LOOKUP_CONCURRENCY = 2;
-const SEND_TO_AGENT_LOOKUP_PAGE_SIZE = 50;
-const SEND_TO_AGENT_LOOKUP_MAX_PAGES = 20;
+const AGENT_LOOKUP_PAGE_SIZE = 100;
+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) {
@@ -33,6 +43,10 @@ function appendClientEventTrace(record) {
         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 `&lt;`, `>`, `&amp;` so sender content can't escape a `&lt;system-reminder>` block. */
 export function sanitizeForSystemReminder(s) {
     return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -42,7 +56,7 @@ export function sanitizeForSystemReminder(s) {
  * that inline context into prompt text (nanoclaw) and `MoltZapService.getContext`
  * share this formatter so sanitization and line shape stay in one place.
  */
-export function formatCrossConversationBlock(entries, opts) {
+function formatCrossConversationBlock(entries, opts) {
     if (entries.length === 0)
         return null;
     const lines = entries.map((e) => {
@@ -91,19 +105,16 @@ function fanout(handlers, arg) {
  * API contract: **every fallible method returns `Effect`.** No `*Async`
  * Promise siblings — async/await consumers run the Effect at the edge
  * with `Effect.runPromise`. Keep this class Effect-only so downstream
- * callers compose failures and cancellation explicitly. (Phase -1
- * vendored the legacy `@moltzap/app-sdk` Promise-shaped wrapper out
- * to arena; consumers wanting Promise wrappers maintain their own.)
+ * callers compose failures and cancellation explicitly.
  */
 export class MoltZapService {
     opts;
     client = null;
     _connected = false;
     /**
-     * Service-owned scope (spec #596 / Spec B §"4.2 service.ts" lifecycle
-     * reshape). Opened in `connect()`, owns the `subscribeAll → Stream.runForEach`
-     * fan-out fiber. Closed in `close()` so the fiber terminates with the
-     * service.
+     * Service-owned scope. Opened in `connect()`, owns the
+     * `subscribeAll → Stream.runForEach` fan-out fiber. Closed in `close()` so
+     * the fiber terminates with the service.
      *
      * Held off the public `connect()` signature so callers do not need to
      * thread a `Scope` requirement.
@@ -134,42 +145,29 @@ export class MoltZapService {
         conversationArchived: [],
         conversationUnarchived: [],
         dispatchRelease: [],
-        dispatchesConsumed: [],
-        dispatchesExpired: [],
+        dispatchLeaseConsumed: [],
+        dispatchLeaseExpired: [],
     };
-    notificationDispatchers = new Map([
-        [
-            MessageReceivedNotificationDefinition,
-            (notification) => this.handleMessageReceivedNotification(notification.params),
-        ],
-        [
-            TaskConversationCreatedNotificationDefinition,
-            (notification) => this.handleConversationCreatedNotification(notification.params),
-        ],
-        [
-            TaskConversationArchivedNotificationDefinition,
-            (notification) => this.handleConversationArchivedNotification(notification.params),
-        ],
-        [
-            TaskConversationUnarchivedNotificationDefinition,
-            (notification) => this.handleConversationUnarchivedNotification(notification.params),
-        ],
-        [
-            DispatchRelease,
-            (notification) => fanout(this.handlers.dispatchRelease, notification.params),
-        ],
-        [
-            DispatchesConsumed,
-            (notification) => fanout(this.handlers.dispatchesConsumed, notification.params),
-        ],
-        [
-            DispatchesExpired,
-            (notification) => fanout(this.handlers.dispatchesExpired, notification.params),
-        ],
-    ]);
     _ownAgentId;
     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;
+    }
+    static fromConfig(config) {
+        return new MoltZapService(config);
+    }
+    static make(profileName) {
+        return loadServiceConfig(profileName).pipe(Effect.map(MoltZapService.fromConfig));
+    }
+    static startDaemon(profileName) {
+        return Effect.gen(function* () {
+            const service = yield* MoltZapService.make(profileName);
+            yield* service.connect();
+            yield* service.startSocketServer();
+            return service;
+        }).pipe(Effect.withSpan("MoltZapService.startDaemon"));
     }
     get connected() {
         return this._connected;
@@ -183,9 +181,9 @@ export class MoltZapService {
             const client = new MoltZapAgentClient({
                 serverUrl: this.opts.serverUrl,
                 agentKey: this.opts.agentKey,
-                // Spec #222 OQ-6: arg required. The body doesn't branch on
-                // close metadata today; signature kept explicit so a future
-                // disconnect-handler chain can plumb code/reason through.
+                // The body doesn't branch on close metadata today; the signature is
+                // kept explicit so a future disconnect-handler chain can plumb
+                // code/reason through.
                 onDisconnect: () => {
                     this._connected = false;
                     fanout(this.handlers.disconnect, undefined);
@@ -196,11 +194,10 @@ export class MoltZapService {
                 },
             });
             this.client = client;
-            // Spec #596 / Spec B Goal #8: the legacy `subscribe({}, handler)` site
-            // is replaced by `subscribeAll().pipe(Stream.runForEach, …)` forked
-            // into a service-owned scope. The Stream is materialized BEFORE
-            // `connect()` so subscriptions are registered with the registry
-            // pre-handshake (pre-connect legality, preserved invariant).
+            // `subscribeAll().pipe(Stream.runForEach, …)` is forked into a
+            // service-owned scope. The Stream is materialized BEFORE `connect()` so
+            // subscriptions are registered with the registry pre-handshake (a
+            // pre-connect-legal operation).
             //
             // Stream errors of type `NotConnectedError` are surfaced on the
             // fiber's failure channel only when the client transitions to
@@ -213,7 +210,6 @@ export class MoltZapService {
             yield* Effect.forkIn(fanoutEffect, serviceScope);
             const helloOk = yield* client.connect();
             this._connected = true;
-            this._ownAgentId = helloOk.agentId;
             return helloOk;
         });
     }
@@ -226,22 +222,15 @@ export class MoltZapService {
     close() {
         this._connected = false;
         Effect.runFork(this.stopSocketServer());
-        // Spec #596 / Spec B §"4.2 service.ts": close the service-owned scope
-        // BEFORE the client. Closing the scope interrupts the
-        // `subscribeAll().pipe(Stream.runForEach, …)` fiber; the client's
-        // `close()` then closes the registry which fires `onClose` on every
-        // live subscription's Stream — but since our consumer fiber has
-        // already been interrupted, the typed-error delivery is to a
-        // terminated consumer (no-op, idempotent).
-        // Order: close the service-scope FIRST (interrupting the
-        // `subscribeAll → runForEach` fiber), THEN close the ws-client.
-        // zipRight chains the two Effects sequentially inside a single
-        // fork so the ordering is honoured deterministically.
         const scopeToClose = this.serviceScope;
         const clientToClose = this.client;
         this.serviceScope = null;
         this.client = null;
-        Effect.runFork(composeServiceTeardown(scopeToClose, clientToClose));
+        const closeScope = scopeToClose === null
+            ? Effect.void
+            : Scope.close(scopeToClose, Exit.void);
+        const closeClient = clientToClose === null ? Effect.void : clientToClose.close();
+        Effect.runFork(closeScope.pipe(Effect.zipRight(closeClient)));
         Effect.runSync(Effect.all([
             Ref.set(this.conversationsRef, HashMap.empty()),
             Ref.set(this.messagesRef, HashMap.empty()),
@@ -287,7 +276,7 @@ export class MoltZapService {
             const running = yield* startLocalSocketServer({
                 socketPath: this.socketPath,
                 defaultSocketPath: MoltZapService.SOCKET_PATH,
-                handleRequest: (method, params) => this.handleSocketRequestEffect(method, params),
+                handlers: this.localDaemonHandlers(),
             });
             this.socketServerScope = running.socketScope;
             this.activeSocketPath = running.socketPath;
@@ -308,36 +297,18 @@ export class MoltZapService {
             defaultSocketPath: MoltZapService.SOCKET_PATH,
         }).pipe(Effect.withSpan("MoltZapService.stopSocketServer"));
     }
-    handleSocketRequestEffect(method, params) {
-        return Effect.suspend(() => {
-            switch (method) {
-                case LocalServiceCommands.Ping:
-                    return Effect.succeed({ ok: true, agentId: this.ownAgentId });
-                case LocalServiceCommands.Status:
-                    return Effect.succeed({
-                        agentId: this.ownAgentId,
-                        connected: this._connected,
-                        conversations: this.getConversations().length,
-                    });
-                case LocalServiceCommands.History:
-                    return this.handleHistoryRequest(params);
-                default: {
-                    const definition = serverRpcMethods.find((d) => d.name === method);
-                    if (definition === undefined ||
-                        !definition.validateParams(params)) {
-                        return Effect.fail(new ServiceInputError({
-                            message: `unknown or invalid RPC method: ${method}`,
-                        }));
-                    }
-                    return this.sendRpc(definition, params);
-                }
-            }
+    localDaemonHandlers() {
+        return makeLocalDaemonHandlers({
+            ownAgentId: this._ownAgentId,
+            connected: this._connected,
+            conversationCount: () => this.getConversations().length,
+            call: this.call.bind(this),
+            handleHistoryRequest: (request) => this.handleHistoryRequest(request),
         });
     }
-    handleHistoryRequest(params) {
+    handleHistoryRequest(request) {
         return Effect.gen(this, function* () {
-            const request = yield* decodeHistoryRequest(params);
-            const result = yield* this.sendRpc(MessagesList, {
+            const result = yield* this.call(MessagesList.name, {
                 taskId: request.taskId,
                 conversationId: request.conversationId,
                 limit: request.limit,
@@ -380,19 +351,13 @@ export class MoltZapService {
             ].filter((id) => !HashMap.has(knownNames, id));
             if (unknownAgentIds.length === 0)
                 return;
-            yield* this.sendRpc(AgentsLookup, { agentIds: unknownAgentIds }).pipe(Effect.tap((result) => Ref.update(this.agentNamesRef, (names) => {
-                let next = names;
-                for (const agent of result.agents) {
-                    next = HashMap.set(next, agent.id, agent.name);
-                }
-                return next;
-            })), Effect.asVoid, Effect.catchAll(() => Effect.void));
+            yield* this.cacheVisibleAgentNamesForIds(new Set(unknownAgentIds)).pipe(Effect.asVoid, Effect.catchAll(() => Effect.void));
         });
     }
     fetchHistoryConversationMeta(convId) {
-        // Spec D3 D10: ConversationsGet retires; client filters
-        // TaskConversationList output for the matching conversation id.
-        return this.sendRpc(TaskConversationList, {}).pipe(Effect.map((result) => {
+        // 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) => {
             const hit = result.items.find((item) => item.conversation.id === convId);
             return hit?.conversation;
         }), Effect.catchAll(() => Effect.succeed(undefined)));
@@ -441,17 +406,16 @@ export class MoltZapService {
      */
     resolveAgentName(agentId) {
         return Effect.gen(this, function* () {
+            const decodedAgentId = Option.getOrUndefined(decodeAgentId(agentId));
+            if (decodedAgentId === undefined)
+                return agentId;
             const cached = Option.getOrUndefined(HashMap.get(snapshot(this.agentNamesRef), agentId));
             if (cached !== undefined)
                 return cached;
-            return yield* this.sendRpc(AgentsLookup, {
-                agentIds: [agentId],
-            }).pipe(Effect.flatMap((result) => {
-                const agent = result.agents[0];
-                if (!agent)
-                    return Effect.succeed(agentId);
-                return Ref.update(this.agentNamesRef, (names) => HashMap.set(names, agentId, agent.name)).pipe(Effect.as(agent.name));
-            }), Effect.catchAll((err) => Effect.logWarning("agents/lookup failed; falling back to agentId").pipe(Effect.annotateLogs({ agentId, err: String(err) }), Effect.as(agentId))));
+            return yield* this.cacheVisibleAgentNamesForIds(new Set([decodedAgentId])).pipe(Effect.map(() => {
+                const resolved = Option.getOrUndefined(HashMap.get(snapshot(this.agentNamesRef), agentId));
+                return resolved ?? agentId;
+            }), Effect.catchAll((err) => Effect.logWarning("agent/identity/agents/list failed; falling back to agentId").pipe(Effect.annotateLogs({ agentId, err: String(err) }), Effect.as(agentId))));
         });
     }
     // --- Messaging ---
@@ -470,8 +434,8 @@ export class MoltZapService {
      *     svc-->>caller: fail(RpcServerError ConversationArchived)
      *   else
      *     svc->>ws: sendRpc(MessagesSend, params)
-     *     Note over ws: stateRef None → fail NotConnectedError<br>otherwise allocate JsonRpcId, encode frame
-     *     ws->>server: {jsonrpc, method messages/send, id, params}
+     *     Note over ws: stateRef None → fail NotConnectedError; otherwise allocate request id, encode frame
+     *     ws->>server: {jsonrpc, method agent/message/send, id, params}
      *     Note over ws: Deferred raced against 30s timeout
      *     server-->>ws: {result, id} or {error, id}
      *     Note over ws: reader fiber decodes, resolves the Deferred
@@ -482,17 +446,14 @@ export class MoltZapService {
      *
      * `opts.dispatchLeaseId` (when set) is forwarded verbatim in the
      * params frame. The server marks the lease consumed, blocking the
-     * TM's timeout sweep. `MoltZapChannelCore.sendReply` forwards
+     * app authorization timeout sweep. `MoltZapChannelCore.sendReply` forwards
      * `leaseIdInFlight` automatically when the caller omits it.
      */
     send(taskId, conversationId, text, opts) {
         if (this.isConversationArchived(conversationId)) {
-            return Effect.fail(new RpcServerError({
-                code: ConversationArchivedError.code,
-                message: "Conversation is archived",
-            }));
+            return Effect.fail(new ConversationArchivedError({ message: "Conversation is archived" }));
         }
-        return Effect.asVoid(this.sendRpc(MessagesSend, {
+        return Effect.asVoid(this.call(MessagesSend.name, {
             taskId,
             conversationId,
             parts: [{ type: "text", text }],
@@ -503,34 +464,23 @@ export class MoltZapService {
         }));
     }
     /**
-     * Issue `dispatch/request`. The server returns the ack
+     * Issue `agent/dispatch/request`. The server returns the ack
      * `{leaseId, dispatchId}` immediately; the recipient observes the
      * verdict asynchronously via the `dispatchRelease` event.
      */
     requestDispatch(params) {
-        return this.sendRpc(DispatchRequest, params);
-    }
-    /**
-     * Issue `dispatches/get`. Moderator-only — calls from non-moderator
-     * connections fail with a typed wire error. The server enforces the
-     * binding tuple recorded at lease-mint time.
-     */
-    dispatchesGet(params) {
-        return this.sendRpc(DispatchesGet, params);
+        return this.call(DispatchRequest.name, params);
     }
     sendToAgent(agentName, text, opts) {
         return Effect.gen(this, function* () {
             const cache = yield* Ref.get(this.agentConversationCacheRef);
             let entry = Option.getOrUndefined(HashMap.get(cache, agentName));
             if (entry === undefined) {
-                const lookupResult = yield* this.sendRpc(AgentsLookupByName, {
-                    names: [agentName],
-                });
-                const agent = lookupResult.agents[0];
+                const agent = yield* this.findVisibleAgentByName(agentName);
                 if (!agent) {
-                    return yield* Effect.fail(new AgentNotFoundError({ agentName }));
+                    return yield* Effect.fail(agentNotFound(agentName));
                 }
-                const createResult = yield* this.sendRpc(TaskRequest, {
+                const createResult = yield* this.call(TaskRequest.name, {
                     appId: DEFAULT_APP_ID,
                     invitedAgentIds: [agent.id],
                     initialConversation: { participants: [agent.id] },
@@ -552,13 +502,13 @@ export class MoltZapService {
     resolveReusableConversationId(taskId, agentName) {
         return Effect.gen(this, function* () {
             let cursor = undefined;
-            for (let page = 0; page < SEND_TO_AGENT_LOOKUP_MAX_PAGES; page++) {
+            for (let page = 0; page < REUSABLE_CONVERSATION_LOOKUP_MAX_PAGES; page++) {
                 const params = {
-                    limit: SEND_TO_AGENT_LOOKUP_PAGE_SIZE,
+                    limit: REUSABLE_CONVERSATION_LOOKUP_PAGE_SIZE,
                 };
                 if (cursor !== undefined)
                     params.cursor = cursor;
-                const result = yield* this.sendRpc(TaskConversationList, 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)
@@ -567,7 +517,54 @@ export class MoltZapService {
                     break;
                 cursor = result.nextCursor;
             }
-            return yield* Effect.fail(new AgentNotFoundError({ agentName }));
+            return yield* Effect.fail(agentNotFound(agentName));
+        });
+    }
+    cacheAgentNames(agents) {
+        if (agents.length === 0)
+            return Effect.void;
+        return Ref.update(this.agentNamesRef, (names) => {
+            let next = names;
+            for (const agent of agents) {
+                next = HashMap.set(next, agent.id, agent.name);
+            }
+            return next;
+        });
+    }
+    agentListParams(cursor) {
+        return cursor === undefined
+            ? { limit: AGENT_LOOKUP_PAGE_SIZE }
+            : { limit: AGENT_LOOKUP_PAGE_SIZE, cursor };
+    }
+    cacheVisibleAgentNamesForIds(agentIds) {
+        return Effect.gen(this, function* () {
+            const missing = new Set(agentIds);
+            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);
+                yield* this.cacheAgentNames(result.agents);
+                for (const agent of result.agents)
+                    missing.delete(agent.id);
+                if (missing.size === 0 || result.nextCursor === undefined)
+                    return;
+                cursor = result.nextCursor;
+            }
+        });
+    }
+    findVisibleAgentByName(agentName) {
+        return Effect.gen(this, function* () {
+            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);
+                yield* this.cacheAgentNames(result.agents);
+                const hit = result.agents.find((agent) => agent.name === agentName);
+                if (hit !== undefined || result.nextCursor === undefined)
+                    return hit;
+                cursor = result.nextCursor;
+            }
+            return undefined;
         });
     }
     // --- Cross-Conversation Context ---
@@ -672,12 +669,27 @@ export class MoltZapService {
         this.handlers[notification].push(handler);
     }
     // --- RPC passthrough ---
-    sendRpc(definition, params, opts) {
+    /**
+     * 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.
+     */
+    call(tag, payload, opts) {
+        return Effect.suspend(() => {
+            const client = this.client;
+            if (!client) {
+                return Effect.fail(new NotConnectedError({ message: "Not connected" }));
+            }
+            return client.call(tag, payload, opts);
+        });
+    }
+    callDefinition(definition, payload, opts) {
         return Effect.suspend(() => {
-            if (!this.client) {
+            const client = this.client;
+            if (!client) {
                 return Effect.fail(new NotConnectedError({ message: "Not connected" }));
             }
-            return this.client.sendRpc(definition, params, opts);
+            return client.callDefinition(definition, payload, opts);
         });
     }
     // --- Internals ---
@@ -690,11 +702,46 @@ export class MoltZapService {
         Effect.runFork(appendClientEventTrace(notificationTraceRecord(notification, this._ownAgentId)));
     }
     dispatchTypedNotification(notification) {
-        const dispatch = this.notificationDispatchers.get(notification.definition);
-        if (dispatch === undefined) {
+        if (this.dispatchMessageNotification(notification))
             return;
+        if (this.dispatchConversationNotification(notification))
+            return;
+        this.dispatchAppNotification(notification);
+    }
+    dispatchMessageNotification(notification) {
+        if (isNotificationDeliveryFor(notification, MessageReceivedNotificationDefinition)) {
+            this.handleMessageReceivedNotification(notification.params);
+            return true;
+        }
+        return false;
+    }
+    dispatchConversationNotification(notification) {
+        if (isNotificationDeliveryFor(notification, ConversationCreatedNotificationDefinition)) {
+            this.handleConversationCreatedNotification(notification.params);
+            return true;
+        }
+        if (isNotificationDeliveryFor(notification, ConversationArchivedNotificationDefinition)) {
+            this.handleConversationArchivedNotification(notification.params);
+            return true;
+        }
+        if (isNotificationDeliveryFor(notification, ConversationUnarchivedNotificationDefinition)) {
+            this.handleConversationUnarchivedNotification(notification.params);
+            return true;
+        }
+        return false;
+    }
+    dispatchAppNotification(notification) {
+        if (isNotificationDeliveryFor(notification, DispatchRelease)) {
+            fanout(this.handlers.dispatchRelease, notification.params);
+            return;
+        }
+        if (isNotificationDeliveryFor(notification, DispatchLeaseConsumed)) {
+            fanout(this.handlers.dispatchLeaseConsumed, notification.params);
+            return;
+        }
+        if (isNotificationDeliveryFor(notification, DispatchLeaseExpired)) {
+            fanout(this.handlers.dispatchLeaseExpired, notification.params);
         }
-        dispatch(notification);
     }
     /**
      * Record `messageId` in the per-conversation dedup window. Returns
@@ -702,10 +749,10 @@ export class MoltZapService {
      * a duplicate within the window (caller drops). On a new id, evicts
      * the oldest entry if the window is full.
      *
-     * Bound to the live `messages/received` notification path: a single
+     * Bound to the live `agent/message/received` notification path: a single
      * server-side broadcast that surfaces the same id twice (network
      * replay, dual subscription) is suppressed to one
-     * `on("message", ...)` event. `messages/list` returns raw history
+     * `on("message", ...)` event. `agent/message/list` returns raw history
      * unfiltered; consumers that combine both feeds dedup themselves.
      */
     recordMessageIdIfNew(convId, msgId) {
@@ -719,7 +766,9 @@ export class MoltZapService {
         }
         if (dedupSet.size >= DEDUP_WINDOW_PER_CONV) {
             // size >= 1 guaranteed by the guard above; next().value is defined.
-            dedupSet.delete(dedupSet.keys().next().value);
+            const oldest = dedupSet.keys().next();
+            if (!oldest.done)
+                dedupSet.delete(oldest.value);
         }
         dedupSet.add(msgId);
         return true;