@moltzap/client 2026.811.0 → 2026.902.0

package/dist/service.js

@@ -1,789 +0,0 @@
-import { agentId as AgentIdSchema, AgentNotFoundError, agentsList, } from "@moltzap/protocol/identity";
-import { agentConversationCreate, conversationCreatedNotificationDefinition, conversationList, } from "@moltzap/protocol/conversation";
-import { messageReceivedNotificationDefinition, messagesList, messagesSend, } from "@moltzap/protocol/message";
-import { NotConnectedError, isNotificationDeliveryFor, } from "@moltzap/protocol/rpc";
-import { BoundedMap } from "./bounded-map.js";
-import { Deferred, 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 { 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 { 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;
-const HISTORY_LOOKUP_CONCURRENCY = 2;
-const AGENT_LOOKUP_PAGE_SIZE = 100;
-const AGENT_LOOKUP_MAX_PAGES = 20;
-const decodeAgentId = Schema.decodeUnknownOption(AgentIdSchema);
-const agentNotFound = (agentName) => new AgentNotFoundError({
-    message: `Agent not found: ${agentName}`,
-    data: { agentName },
-});
-/**
- * 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;");
-}
-/**
- * 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) {
-        return null;
-    }
-    const lines = entries.map((e) => {
-        const safeSender = sanitizeForSystemReminder(e.senderName);
-        const safeText = sanitizeForSystemReminder(e.text.slice(0, CROSS_CONTEXT_TEXT_LIMIT));
-        return `@${safeSender} (${e.minutesAgo}m ago): (${e.count} new) "${safeText}"`;
-    });
-    return [
-        "<system-reminder>",
-        opts.header,
-        ...lines,
-        "</system-reminder>",
-    ].join("\n");
-}
-/**
- * Per-conversation message cap. Older messages are evicted FIFO; the
- * on-disk history remains the source of truth. Sized for typical CLI
- * display windows — `conversations get` shows at most a few hundred.
- */
-const MAX_MESSAGES_PER_CONV = 1000;
-/**
- * Per-conversation dedup window. `BoundedMap` evicts the oldest message id
- * when a new id arrives at capacity. 1000 × 36 bytes per UUID ≈ 36 KB per
- * conversation, which keeps replay protection negligible at the expected
- * conversation count.
- */
-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) {
-        try {
-            h(arg);
-        }
-        catch (err) {
-            Effect.runFork(Effect.logError("notification handler threw", err));
-        }
-    }
-}
-/**
- * Stateful MoltZap client that manages connection, conversation tracking,
- * agent name resolution, and cross-conversation context generation.
- *
- * 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.
- */
-export class MoltZapService {
-    client = null;
-    connectedValue = false;
-    shutdownCompletion = null;
-    /**
-     * 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.
-     */
-    serviceScope = null;
-    conversationsRef = Effect.runSync(Ref.make(HashMap.empty()));
-    messagesRef = Effect.runSync(Ref.make(HashMap.empty()));
-    agentNamesRef = Effect.runSync(Ref.make(HashMap.empty()));
-    agentConversationCacheRef = Effect.runSync(Ref.make(HashMap.empty()));
-    lastNotifiedRef = Effect.runSync(Ref.make(HashMap.empty()));
-    lastReadRef = Effect.runSync(Ref.make(HashMap.empty()));
-    /**
-     * The branded outer and inner keys keep conversation and message ids from
-     * crossing accidentally while each conversation owns its eviction window.
-     */
-    seenMessageIds = new Map();
-    handlers = {
-        message: [],
-        rawNotification: [],
-        disconnect: [],
-    };
-    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.ownAgentIdValue = opts.agentId;
-    }
-    static fromConfig(config) {
-        return new MoltZapService(config);
-    }
-    static make(profileName) {
-        return loadServiceConfig(profileName).pipe(Effect.map((config) => MoltZapService.fromConfig(config)));
-    }
-    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.connectedValue;
-    }
-    get ownAgentId() {
-        return this.ownAgentIdValue;
-    }
-    /**
-     * Effect-native: compose via `yield*` or bridge at the edge via `Effect.runPromise`.
-     * @returns The client result.
-     */
-    connect() {
-        return Effect.gen(function* () {
-            // A new connection never takes ownership while resources from the
-            // preceding lifecycle are still closing.
-            while (this.shutdownCompletion !== null) {
-                const priorShutdown = this.shutdownCompletion;
-                yield* Deferred.await(priorShutdown);
-                if (this.shutdownCompletion === priorShutdown) {
-                    this.shutdownCompletion = null;
-                }
-            }
-            const client = new MoltZapAgentClient({
-                serverUrl: this.opts.serverUrl,
-                agentKey: this.opts.agentKey,
-                // 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.connectedValue = false;
-                    fanout(this.handlers.disconnect, undefined);
-                },
-            });
-            this.client = client;
-            // `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
-            // terminal closed state (close() path); `Effect.catchAll` here
-            // would swallow them silently, so we route through `Effect.logError`
-            // 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);
-            yield* Effect.forkIn(fanoutEffect, serviceScope);
-            const helloOk = yield* client.connect();
-            this.connectedValue = true;
-            return helloOk;
-        }.bind(this));
-    }
-    /**
-     * Returns a lazy teardown effect that resolves after the service's owned
-     * transports and notification scope close.
-     *
-     * @returns Completion of the service-owned cleanup.
-     * @internal
-     */
-    shutdown() {
-        return Effect.suspend(() => this.beginShutdown());
-    }
-    beginShutdown() {
-        if (this.shutdownCompletion !== null) {
-            return Deferred.await(this.shutdownCompletion);
-        }
-        const shutdownCompletion = Effect.runSync(Deferred.make());
-        this.shutdownCompletion = shutdownCompletion;
-        this.connectedValue = false;
-        const stopSocketServer = this.stopSocketServer();
-        const scopeToClose = this.serviceScope;
-        const clientToClose = this.client;
-        this.serviceScope = null;
-        this.client = null;
-        const closeScope = scopeToClose === null
-            ? Effect.void
-            : Scope.close(scopeToClose, Exit.void);
-        const closeClient = clientToClose === null ? Effect.void : clientToClose.close();
-        Effect.runSync(Effect.all([
-            Ref.set(this.conversationsRef, HashMap.empty()),
-            Ref.set(this.messagesRef, HashMap.empty()),
-            Ref.set(this.agentNamesRef, HashMap.empty()),
-            Ref.set(this.agentConversationCacheRef, HashMap.empty()),
-            Ref.set(this.lastNotifiedRef, HashMap.empty()),
-            Ref.set(this.lastReadRef, HashMap.empty()),
-        ]));
-        this.seenMessageIds.clear();
-        // 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.
-        return Effect.uninterruptible(Effect.all([stopSocketServer, closeScope.pipe(Effect.zipRight(closeClient))], { concurrency: 2, discard: true }).pipe(Effect.ensuring(Deferred.succeed(shutdownCompletion, undefined).pipe(Effect.asVoid))));
-    }
-    /**
-     * Starts service teardown for callers that use the legacy synchronous
-     * lifecycle boundary.
-     */
-    close() {
-        Effect.runFork(this.beginShutdown());
-    }
-    // --- Socket Server ---
-    socketServerScope = null;
-    activeSocketPath = null;
-    /** Default socket path for CLI discovery. Per-instance path uses agentId. */
-    static SOCKET_PATH = getMoltZapServiceSocketPath();
-    /**
-     * `agentId` is a server-assigned string. Treat it as untrusted: if a
-     * 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.
-     * @returns The id result.
-     */
-    get socketPath() {
-        const id = MoltZapService.safeAgentIdSegment(this.ownAgentId ?? "default");
-        return getMoltZapAgentServiceSocketPath(id);
-    }
-    startSocketServer() {
-        return Effect.gen(function* () {
-            const previous = this.resetSocketServerState();
-            yield* stopLocalSocketServer({
-                socketScope: previous.socketScope,
-                socketPath: previous.sockPath,
-                defaultSocketPath: MoltZapService.SOCKET_PATH,
-            });
-            const running = yield* startLocalSocketServer({
-                socketPath: this.socketPath,
-                defaultSocketPath: MoltZapService.SOCKET_PATH,
-                handlers: this.localDaemonHandlers(),
-            });
-            this.socketServerScope = running.socketScope;
-            this.activeSocketPath = running.socketPath;
-        }.bind(this)).pipe(Effect.withSpan("MoltZapService.startSocketServer"));
-    }
-    resetSocketServerState() {
-        const socketScope = this.socketServerScope;
-        this.socketServerScope = null;
-        const sockPath = this.activeSocketPath ?? this.socketPath;
-        this.activeSocketPath = null;
-        return { socketScope, sockPath };
-    }
-    stopSocketServer() {
-        const { socketScope, sockPath } = this.resetSocketServerState();
-        return stopLocalSocketServer({
-            socketScope,
-            socketPath: sockPath,
-            defaultSocketPath: MoltZapService.SOCKET_PATH,
-        }).pipe(Effect.withSpan("MoltZapService.stopSocketServer"));
-    }
-    localDaemonHandlers() {
-        return makeLocalDaemonHandlers({
-            ownAgentId: this.ownAgentIdValue,
-            // A live thunk, not a snapshot: the handler table outlives connection
-            // cycles, and daemon/status must report the same liveness the MCP
-            // status tool reads.
-            connected: () => this.connectedValue,
-            conversationCount: () => this.getConversations().length,
-            call: this.call.bind(this),
-            handleHistoryRequest: (request) => this.handleHistoryRequest(request),
-        });
-    }
-    handleHistoryRequest(request) {
-        return Effect.gen(function* () {
-            const result = yield* this.call(messagesList.name, {
-                conversationId: request.conversationId,
-                limit: request.limit,
-            });
-            const convMeta = yield* this.loadHistorySupportData(request.conversationId, result.messages);
-            const agentNames = yield* Ref.get(this.agentNamesRef);
-            const lastReadMap = yield* Ref.get(this.lastReadRef);
-            const lastReadIds = lastReadIdsForSession(lastReadMap, request);
-            const messages = result.messages.map((message) => formatHistoryMessage(message, {
-                agentNames,
-                ownAgentId: this.ownAgentId,
-                lastReadIds,
-                hasSessionKey: request.sessionKey !== undefined,
-            }));
-            yield* this.advanceHistoryLastRead(request, result.messages);
-            return {
-                messages,
-                conversationMeta: convMeta,
-                newCount: messages.filter((message) => message.isNew).length,
-            };
-        }.bind(this));
-    }
-    loadHistorySupportData(convId, messages) {
-        return Effect.gen(function* () {
-            const [, convMeta] = yield* Effect.all([
-                this.refreshHistoryAgentNames(messages),
-                this.fetchHistoryConversationMeta(convId),
-            ], {
-                concurrency: HISTORY_LOOKUP_CONCURRENCY,
-            });
-            return convMeta;
-        }.bind(this));
-    }
-    refreshHistoryAgentNames(messages) {
-        return Effect.gen(function* () {
-            const knownNames = yield* Ref.get(this.agentNamesRef);
-            const unknownAgentIds = [
-                ...new Set(messages.map((message) => message.senderId)),
-            ].filter((id) => !HashMap.has(knownNames, id));
-            if (unknownAgentIds.length === 0) {
-                return;
-            }
-            yield* this.cacheVisibleAgentNamesForIds(new Set(unknownAgentIds)).pipe(Effect.asVoid, Effect.catchAll(() => Effect.void));
-        }.bind(this));
-    }
-    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) => {
-            const hit = result.items.find((item) => item.conversation.id === convId);
-            return hit?.conversation;
-        }), Effect.orElseSucceed(() => undefined));
-    }
-    advanceHistoryLastRead(request, messages) {
-        if (request.sessionKey === undefined || messages.length === 0) {
-            return Effect.void;
-        }
-        const { conversationId, sessionKey } = request;
-        return Ref.update(this.lastReadRef, (outer) => {
-            const perSession = getOr(outer, sessionKey, () => HashMap.empty());
-            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);
-            }
-            return HashMap.set(outer, sessionKey, HashMap.set(perSession, conversationId, nextSet));
-        });
-    }
-    // --- Conversations ---
-    getConversation(convId) {
-        return Option.getOrUndefined(HashMap.get(snapshot(this.conversationsRef), convId));
-    }
-    getConversations() {
-        return [...HashMap.values(snapshot(this.conversationsRef))];
-    }
-    // --- Messages ---
-    getHistory(convId, limit) {
-        const msgs = getOr(snapshot(this.messagesRef), convId, () => []);
-        return limit ? msgs.slice(-limit) : [...msgs];
-    }
-    // --- Agent Names ---
-    getAgentName(agentId) {
-        return Option.getOrUndefined(HashMap.get(snapshot(this.agentNamesRef), agentId));
-    }
-    /**
-     * Cache-first agent-name lookup. Never fails: falls back to `agentId`
-     * 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(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.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))));
-        }.bind(this));
-    }
-    // --- Messaging ---
-    /**
-     * Send a text message into a conversation.
-     *
-     * ```mermaid
-     * sequenceDiagram
-     *   participant caller
-     *   participant svc as MoltZapService
-     *   participant ws as MoltZapAgentClient
-     *   participant server
-     *
-     *   caller->>svc: send(convId, text, opts?)
-     *   svc->>ws: sendRpc(MessagesSend, 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
-     *   ws-->>svc: result or RpcServerError or RpcTimeoutError
-     *   svc-->>caller: Effect.void
-     * ```
-     *
-     * @param conversationId Value supplied to the operation.
-     * @param text Text to process.
-     * @returns The send result.
-     */
-    send(conversationId, text) {
-        return Effect.asVoid(this.call(messagesSend.name, {
-            conversationId,
-            parts: [{ type: "text", text }],
-        }));
-    }
-    /**
-     * Send to a named agent, minting the DM conversation on first use and
-     * reusing it afterwards. The per-name cache is what makes the DM stable:
-     * `agent/conversation/create` mints a fresh conversation on every call.
-     * @param agentName Name of the agent to reach.
-     * @param text Text to process.
-     * @returns The send result.
-     */
-    sendToAgent(agentName, text) {
-        return Effect.gen(function* () {
-            const cache = yield* Ref.get(this.agentConversationCacheRef);
-            let conversationId = Option.getOrUndefined(HashMap.get(cache, agentName));
-            if (conversationId === undefined) {
-                const agent = yield* this.findVisibleAgentByName(agentName);
-                if (!agent) {
-                    return yield* agentNotFound(agentName);
-                }
-                const created = yield* this.call(agentConversationCreate.name, {
-                    participants: [agent.id],
-                });
-                conversationId = created.conversation.id;
-                const cached = conversationId;
-                yield* Ref.update(this.agentConversationCacheRef, (m) => HashMap.set(m, agentName, cached));
-            }
-            yield* this.send(conversationId, text);
-        }.bind(this));
-    }
-    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(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;
-            }
-        }.bind(this));
-    }
-    findVisibleAgentByName(agentName) {
-        return Effect.gen(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;
-        }.bind(this));
-    }
-    // --- Cross-Conversation Context ---
-    /**
-     * 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) {
-            return null;
-        }
-        commit();
-        return formatCrossConversationBlock(entries, {
-            header: `Recent updates (you are in conv:${currentConvId}):`,
-        });
-    }
-    /**
-     * Return recent activity in other conversations without advancing any state.
-     * 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;
-        const maxMsgsPerConv = opts?.maxMessagesPerConv ?? DEFAULT_MAX_MESSAGES_PER_CONVERSATION;
-        const state = this.readCrossConvState(currentConvId);
-        const candidates = this.collectContextCandidates(state, currentConvId);
-        const { entries, pendingAdvances } = buildContextEntries(candidates.slice(0, maxConvs), state, maxMsgsPerConv);
-        return {
-            entries,
-            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);
-        const allMessages = [];
-        const pendingAdvances = [];
-        for (const [convId, newMsgs] of this.iterNewMessagesByConv(messagesMap, viewMarkers, currentConvId)) {
-            const convName = Option.getOrUndefined(HashMap.get(conversationsMap, convId))?.name;
-            for (const m of newMsgs) {
-                allMessages.push({
-                    conversationId: convId,
-                    conversationName: convName,
-                    senderName: getOr(agentNamesMap, m.senderId, () => m.senderId),
-                    senderId: m.senderId,
-                    text: m.parts.map(renderPart).join(" "),
-                    timestamp: m.createdAt,
-                });
-            }
-            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);
-            },
-        };
-    }
-    readCrossConvState(currentConvId) {
-        const lastNotifiedMap = snapshot(this.lastNotifiedRef);
-        return {
-            messagesMap: snapshot(this.messagesRef),
-            conversationsMap: snapshot(this.conversationsRef),
-            agentNamesMap: snapshot(this.agentNamesRef),
-            viewMarkers: getOr(lastNotifiedMap, currentConvId, () => HashMap.empty()),
-        };
-    }
-    collectContextCandidates(state, currentConvId) {
-        const candidates = [];
-        for (const [convId, newMsgs] of this.iterNewMessagesByConv(state.messagesMap, state.viewMarkers, currentConvId)) {
-            candidates.push(makeContextCandidate(convId, newMsgs));
-        }
-        candidates.sort((a, b) => b.lastTs - a.lastTs);
-        return candidates;
-    }
-    *iterNewMessagesByConv(messagesMap, viewMarkers, currentConvId) {
-        for (const [convId, msgs] of messagesMap) {
-            const newMsgs = newMessagesForConversation(convId, msgs, viewMarkers, currentConvId);
-            if (newMsgs.length > 0) {
-                yield [convId, newMsgs];
-            }
-        }
-    }
-    advanceLastNotified(currentConvId, pendingAdvances) {
-        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) {
-                markers = HashMap.set(markers, convId, msgId);
-            }
-            return HashMap.set(outer, currentConvId, markers);
-        }));
-    }
-    // --- Notifications ---
-    on(notification, handler) {
-        this.handlers[notification].push(handler);
-    }
-    // --- RPC passthrough ---
-    /**
-     * 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(() => {
-            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(() => {
-            const client = this.client;
-            if (!client) {
-                return Effect.fail(new NotConnectedError({ message: "Not connected" }));
-            }
-            return client.callDefinition(definition, payload, opts);
-        });
-    }
-    // --- Internals ---
-    handleNotification(notification) {
-        this.recordNotificationTrace(notification);
-        fanout(this.handlers.rawNotification, notification);
-        this.dispatchTypedNotification(notification);
-    }
-    recordNotificationTrace(notification) {
-        Effect.runFork(appendClientEventTrace(notificationTraceRecord(notification, this.ownAgentIdValue)));
-    }
-    dispatchTypedNotification(notification) {
-        if (this.dispatchMessageNotification(notification)) {
-            return;
-        }
-        this.dispatchConversationNotification(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;
-        }
-        return false;
-    }
-    /**
-     * Record `messageId` in the per-conversation dedup window. Returns
-     * `true` when the id is new (caller proceeds), `false` when the id is
-     * a duplicate within the window (caller drops). On a new id, evicts
-     * the oldest entry if the window is full.
-     *
-     * 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. `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);
-        if (dedupWindow === undefined) {
-            dedupWindow = new BoundedMap(DEDUP_WINDOW_PER_CONV);
-            this.seenMessageIds.set(convId, dedupWindow);
-        }
-        if (dedupWindow.has(msgId)) {
-            // Replays retain their original FIFO age so repeated delivery cannot
-            // keep an old id resident forever.
-            return false;
-        }
-        dedupWindow.set(msgId, true);
-        return true;
-    }
-    handleMessageReceivedNotification(notification) {
-        const msg = notification.message;
-        const convId = msg.conversationId;
-        if (!this.recordMessageIdIfNew(convId, msg.id)) {
-            return;
-        }
-        this.storeMessage(msg);
-        // 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.ownAgentIdValue) {
-            fanout(this.handlers.message, { message: msg });
-        }
-    }
-    handleConversationCreatedNotification(notification) {
-        const { conversationId, name, participants } = notification;
-        Effect.runSync(Ref.update(this.conversationsRef, (m) => {
-            // The notification carries the full membership, this agent included,
-            // so anything past two members is a group.
-            const inferredType = participants.length <= 2 ? "dm" : "group";
-            return HashMap.set(m, conversationId, {
-                id: conversationId,
-                type: inferredType,
-                participants: participants.map((p) => `agent:${p}`),
-                ...(name !== undefined ? { name } : {}),
-            });
-        }));
-    }
-    storeMessage(msg) {
-        Effect.runSync(Ref.update(this.messagesRef, (m) => {
-            const existing = getOr(m, msg.conversationId, () => []);
-            const appended = [...existing, msg];
-            const capped = appended.length > MAX_MESSAGES_PER_CONV
-                ? appended.slice(-MAX_MESSAGES_PER_CONV)
-                : appended;
-            return HashMap.set(m, msg.conversationId, capped);
-        }));
-    }
-}
-//# sourceMappingURL=service.js.map