@otto-code/client 0.8.10 → 0.8.13

package/dist/daemon-client.js

@@ -117,6 +117,7 @@ function toTimeoutError(error, label, timeoutMs) {
 const DEFAULT_RECONNECT_BASE_DELAY_MS = 1500;
 const DEFAULT_RECONNECT_MAX_DELAY_MS = 30000;
 const DEFAULT_SESSION_RPC_TIMEOUT_MS = 60000;
+const PUSH_TOKEN_REVOCATION_TIMEOUT_MS = 2000;
 const DEFAULT_CONNECT_TIMEOUT_MS = 15000;
 const DEFAULT_LIVENESS_TIMEOUT_MS = 5000;
 const LIVENESS_HEARTBEAT_INTERVAL_MS = 10000;
@@ -185,6 +186,21 @@ function concatByteChunks(chunks, size) {
     }
     return bytes;
 }
+function getTransportFrameSize(frame) {
+    if (typeof frame === "string") {
+        return frame.length;
+    }
+    return frame.byteLength;
+}
+function describeInboundTransportFrame(frame, rawBytes) {
+    if (typeof frame === "string") {
+        return { kind: "text", size: String(frame.length) };
+    }
+    if (rawBytes) {
+        return { kind: "binary", size: String(rawBytes.byteLength) };
+    }
+    return { kind: "unknown", size: "0" };
+}
 function hashForLog(value) {
     let hash = 0;
     for (let index = 0; index < value.length; index += 1) {
@@ -595,6 +611,45 @@ export class DaemonClient {
     // ============================================================================
     // Core Send Helpers
     // ============================================================================
+    beginTraceSection(name, args) {
+        const trace = this.config.trace;
+        if (!trace?.isEnabled()) {
+            return false;
+        }
+        trace.beginSection(name, args);
+        return true;
+    }
+    endTraceSection(isOpen) {
+        if (isOpen) {
+            this.config.trace?.endSection();
+        }
+    }
+    traceInstant(name, args) {
+        const isOpen = this.beginTraceSection(name, args);
+        this.endTraceSection(isOpen);
+    }
+    sendJsonMessage(envelopeType, messageType, message) {
+        this.traceInstant("otto.ws.message.outbound", {
+            envelopeType,
+            messageType,
+        });
+        this.sendTransportFrame(JSON.stringify(message));
+    }
+    sendTransportFrame(frame) {
+        if (!this.transport) {
+            throw new Error("Transport not connected");
+        }
+        const isOpen = this.beginTraceSection("otto.ws.frame.outbound", {
+            kind: typeof frame === "string" ? "text" : "binary",
+            size: String(getTransportFrameSize(frame)),
+        });
+        try {
+            this.transport.send(frame);
+        }
+        finally {
+            this.endTraceSection(isOpen);
+        }
+    }
     /**
      * Send a session message. For fire-and-forget messages (heartbeats, etc.),
      * failures are suppressed if `suppressSendErrors` is configured.
@@ -609,7 +664,7 @@ export class DaemonClient {
         }
         const payload = SessionInboundMessageSchema.parse(message);
         try {
-            this.transport.send(JSON.stringify({ type: "session", message: payload }));
+            this.sendJsonMessage("session", payload.type, { type: "session", message: payload });
         }
         catch (error) {
             if (this.config.suppressSendErrors) {
@@ -626,7 +681,11 @@ export class DaemonClient {
             throw new Error(`Transport not connected (status: ${this.connectionState.status})`);
         }
         try {
-            this.transport.send(frame);
+            this.traceInstant("otto.ws.message.outbound", {
+                envelopeType: "binary",
+                messageType: "binary",
+            });
+            this.sendTransportFrame(frame);
         }
         catch (error) {
             if (this.config.suppressSendErrors) {
@@ -646,7 +705,7 @@ export class DaemonClient {
         // If connected, send immediately
         if (this.transport && status === "connected") {
             const payload = SessionInboundMessageSchema.parse(message);
-            this.transport.send(JSON.stringify({ type: "session", message: payload }));
+            this.sendJsonMessage("session", payload.type, { type: "session", message: payload });
             return Promise.resolve();
         }
         // If connecting, queue the message to be sent once connected
@@ -677,7 +736,7 @@ export class DaemonClient {
             try {
                 if (this.transport && this.connectionState.status === "connected") {
                     const payload = SessionInboundMessageSchema.parse(pending.message);
-                    this.transport.send(JSON.stringify({ type: "session", message: payload }));
+                    this.sendJsonMessage("session", payload.type, { type: "session", message: payload });
                     pending.resolve();
                 }
                 else {
@@ -785,7 +844,7 @@ export class DaemonClient {
         }
         const payload = SessionInboundMessageSchema.parse(message);
         try {
-            this.transport.send(JSON.stringify({ type: "session", message: payload }));
+            this.sendJsonMessage("session", payload.type, { type: "session", message: payload });
         }
         catch (error) {
             throw error instanceof Error ? error : new Error(String(error));
@@ -855,6 +914,15 @@ export class DaemonClient {
             token,
         });
     }
+    async unregisterPushToken(token) {
+        const requestId = this.createRequestId();
+        await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "push.unregister.request", token, requestId },
+            responseType: "push.unregister.response",
+            timeout: PUSH_TOKEN_REVOCATION_TIMEOUT_MS,
+        });
+    }
     async ping(params) {
         const requestId = params?.requestId ?? `ping-${Date.now()}-${Math.random().toString(36).slice(2)}`;
         const clientSentAt = Date.now();
@@ -934,7 +1002,7 @@ export class DaemonClient {
         };
         this.pingProbe = probe;
         try {
-            this.transport.send(JSON.stringify({ type: "ping" }));
+            this.sendJsonMessage("ping", "ping", { type: "ping" });
         }
         catch (error) {
             this.clearPingProbe();
@@ -1007,6 +1075,7 @@ export class DaemonClient {
             type: "fetch_agent_history_request",
             requestId: resolvedRequestId,
             ...(options?.filter ? { filter: options.filter } : {}),
+            ...(options?.search ? { search: options.search } : {}),
             ...(options?.sort ? { sort: options.sort } : {}),
             ...(options?.page ? { page: options.page } : {}),
         });
@@ -1757,6 +1826,35 @@ export class DaemonClient {
         }
         return { customName: payload.customName };
     }
+    /**
+     * Sets (or with a null target, clears) which tracking board a project shows
+     * on the Kanban screen. The daemon normalizes what it stores - a pasted board
+     * URL comes back as the parsed id - so the caller should render the returned
+     * target rather than its own draft.
+     */
+    async setKanbanProjectTarget(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "kanban.project.target.set.request",
+                projectId: input.projectId,
+                target: input.target,
+            },
+            responseType: "kanban.project.target.set.response",
+        });
+        if (!payload.accepted) {
+            throw new Error(payload.error ?? "setKanbanProjectTarget rejected");
+        }
+        return { target: payload.target };
+    }
+    async setProjectIcon(projectId, source, requestId) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: { type: "project.icon.set.request", projectId, source },
+        });
+        if (!payload.accepted)
+            throw new Error(payload.error ?? "setProjectIcon rejected");
+    }
     async removeProject(projectId, requestId) {
         const payload = await this.sendNamespacedCorrelatedSessionRequest({
             requestId,
@@ -2004,6 +2102,58 @@ export class DaemonClient {
             },
         });
     }
+    /**
+     * The provider-agnostic Kanban board surface. Each call names its provider
+     * ("memory", "github", ...) - the daemon dispatches to the registered
+     * KanbanProvider implementation and the wire never carries provider-native
+     * identifiers beyond the opaque board/card/column ids.
+     *
+     * A project-scoped request is authoritative: the daemon resolves the
+     * project's configured board target and overrides providerId from it. The
+     * wire still carries providerId so older clients keep working; pass an inert
+     * value (e.g. "github") when a project is supplied.
+     */
+    async kanbanListBoards(input, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "kanban.boards.list.request",
+                providerId: input.providerId,
+                ...(input.projectId ? { projectId: input.projectId } : {}),
+                ...(input.projectKey ? { projectKey: input.projectKey } : {}),
+                requestId: "",
+            },
+            timeout: 60000,
+        });
+    }
+    async kanbanGetBoard(providerId, boardId, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: { type: "kanban.board.get.request", providerId, boardId, requestId: "" },
+            timeout: 60000,
+        });
+    }
+    async kanbanMoveCard(input, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: { ...input, type: "kanban.card.move.request", requestId: "" },
+            timeout: 60000,
+        });
+    }
+    async kanbanCreateCard(input, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: { ...input, type: "kanban.card.create.request", requestId: "" },
+            timeout: 60000,
+        });
+    }
+    async kanbanLinkTask(input, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: { ...input, type: "kanban.task.link.request", requestId: "" },
+            timeout: 60000,
+        });
+    }
     async getCommitFileDiff(cwd, sha, path, requestId) {
         const payload = await this.sendNamespacedCorrelatedSessionRequest({
             requestId,
@@ -2189,6 +2339,7 @@ export class DaemonClient {
             ...(options.cursor ? { cursor: options.cursor } : {}),
             ...(typeof options.limit === "number" ? { limit: options.limit } : {}),
             ...(options.projection ? { projection: options.projection } : {}),
+            ...(options.mergeWindow === true ? { mergeWindow: true } : {}),
         });
         const payload = await this.sendRequest({
             requestId: resolvedRequestId,
@@ -2210,6 +2361,28 @@ export class DaemonClient {
         }
         return payload;
     }
+    async listAgentTimelinePrompts(agentId, options = {}) {
+        const requestId = this.createRequestId(options.requestId);
+        const message = SessionInboundMessageSchema.parse({
+            type: "agent.timeline.list_prompts.request",
+            agentId,
+            requestId,
+        });
+        const payload = await this.sendRequest({
+            requestId,
+            message,
+            timeout: options.timeout,
+            options: { skipQueue: true },
+            select: (response) => response.type === "agent.timeline.list_prompts.response" &&
+                response.payload.requestId === requestId
+                ? response.payload
+                : null,
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload;
+    }
     async buildAgentForkContext(agentId, options = {}) {
         const resolvedRequestId = this.createRequestId(options.requestId);
         const message = SessionInboundMessageSchema.parse({
@@ -2574,6 +2747,40 @@ export class DaemonClient {
         }
         return payload.notice ?? null;
     }
+    /**
+     * Applies a whole agent-config bundle in one request. Use this instead of
+     * chaining the single-field setters when the values belong together so client
+     * interruption and other mutations cannot interleave between steps. A
+     * provider rejection can still leave earlier steps applied.
+     * Gated on `server_info.features.agentConfigApply`.
+     */
+    async applyAgentConfig(agentId, config) {
+        const requestId = this.createRequestId();
+        const message = SessionInboundMessageSchema.parse({
+            type: "agent.config.apply.request",
+            agentId,
+            config,
+            requestId,
+        });
+        const payload = await this.sendRequest({
+            requestId,
+            message,
+            options: { skipQueue: true },
+            select: (msg) => {
+                if (msg.type !== "agent.config.apply.response") {
+                    return null;
+                }
+                if (msg.payload.requestId !== requestId) {
+                    return null;
+                }
+                return msg.payload;
+            },
+        });
+        if (!payload.accepted) {
+            throw new Error(payload.error ?? "applyAgentConfig rejected");
+        }
+        return payload.notice ?? null;
+    }
     async restartServer(reason, requestId) {
         const resolvedRequestId = this.createRequestId(requestId);
         const message = SessionInboundMessageSchema.parse({
@@ -3140,6 +3347,16 @@ export class DaemonClient {
             responseType: "checkout.refresh.response",
         });
     }
+    async checkoutGitFetch(cwd, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "checkout.git.fetch.request",
+                cwd,
+            },
+            responseType: "checkout.git.fetch.response",
+        });
+    }
     async checkoutPrCreate(cwd, input, requestId) {
         return this.sendCorrelatedSessionRequest({
             requestId,
@@ -3629,48 +3846,6 @@ export class DaemonClient {
             requestId: input.requestId,
         }));
     }
-    /** Create an empty file or a directory. Never overwrites - see FileCreateResultSchema. */
-    async createFileEntry(options) {
-        const payload = await this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "file.create.request",
-                cwd: options.cwd,
-                path: options.path,
-                kind: options.kind,
-            },
-            responseType: "file.create.response",
-        });
-        return payload.result;
-    }
-    /** Permanent delete - an unlink, not a move to any trash. */
-    async deleteFileEntry(options) {
-        const payload = await this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "file.delete.request",
-                cwd: options.cwd,
-                path: options.path,
-                recursive: options.recursive,
-            },
-            responseType: "file.delete.response",
-        });
-        return payload.result;
-    }
-    /** Rename, which is also move. Never clobbers an occupied destination. */
-    async renameFileEntry(options) {
-        const payload = await this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "file.rename.request",
-                cwd: options.cwd,
-                path: options.path,
-                newPath: options.newPath,
-            },
-            responseType: "file.rename.response",
-        });
-        return payload.result;
-    }
     async refineFile(options) {
         const payload = await this.sendCorrelatedSessionRequest({
             requestId: options.requestId,
@@ -4363,6 +4538,7 @@ export class DaemonClient {
             message: {
                 type: "get_providers_snapshot_request",
                 cwd: options?.cwd,
+                ifNoneMatch: options?.ifNoneMatch,
             },
             responseType: "get_providers_snapshot_response",
         });
@@ -4456,6 +4632,208 @@ export class DaemonClient {
             responseType: "connectors.oauth.disconnect.response",
         });
     }
+    /**
+     * Read the daemon-owned, provider-neutral communications inbox projection.
+     * Requires server_info.features.communications; callers own that one gate.
+     */
+    async communicationsGetOverview(requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "communications.get_overview.request" },
+            responseType: "communications.get_overview.response",
+        });
+        return payload.overview;
+    }
+    async communicationsInboxGetHome(providerId, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "communications.inbox.get_home.request", providerId },
+            responseType: "communications.inbox.get_home.response",
+        });
+        return payload.home;
+    }
+    async communicationsInboxAcknowledgeNotifications(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "communications.inbox.notifications.acknowledge.request", ...input },
+            responseType: "communications.inbox.notifications.acknowledge.response",
+        });
+        return payload.home;
+    }
+    async communicationsInboxSearch(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "communications.inbox.search.request", ...input },
+            responseType: "communications.inbox.search.response",
+        });
+        return payload.results;
+    }
+    async communicationsInboxSetFavorite(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "communications.inbox.set_favorite.request", ...input },
+            responseType: "communications.inbox.set_favorite.response",
+        });
+        return payload.home;
+    }
+    async communicationsInboxGetPresence(providerId, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "communications.inbox.get_presence.request", providerId },
+            responseType: "communications.inbox.get_presence.response",
+        });
+        return payload.presence;
+    }
+    async communicationsInboxSetPresence(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "communications.inbox.set_presence.request", ...input },
+            responseType: "communications.inbox.set_presence.response",
+        });
+        return payload.presence;
+    }
+    async communicationsInboxSetEnabled(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "communications.inbox.set_enabled.request", ...input },
+            responseType: "communications.inbox.set_enabled.response",
+        });
+        return payload.presence;
+    }
+    async communicationsInboxGetMessages(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "communications.inbox.get_messages.request", ...input },
+            responseType: "communications.inbox.get_messages.response",
+        });
+        return payload.messages;
+    }
+    async communicationsInboxSendMessage(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "communications.inbox.send_message.request", ...input },
+            responseType: "communications.inbox.send_message.response",
+        });
+        return payload.message;
+    }
+    /** Requires server_info.features.communicationsRooms. */
+    async communicationsRoomGet(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "communications.room.get.request", ...input },
+            responseType: "communications.room.get.response",
+        });
+        return payload.room;
+    }
+    async communicationsRoomThreadGet(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "communications.room.thread.get.request", ...input },
+            responseType: "communications.room.thread.get.response",
+        });
+        return payload.messages;
+    }
+    async communicationsRoomMessageSend(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "communications.room.message.send.request", ...input },
+            responseType: "communications.room.message.send.response",
+        });
+        return payload.message;
+    }
+    async communicationsRoomReactionSet(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "communications.room.reaction.set.request", ...input },
+            responseType: "communications.room.reaction.set.response",
+        });
+        return payload.message;
+    }
+    /**
+     * Daemon-owned meeting transcript library. Requires
+     * `server_info.features.meetingTranscripts`; callers own that capability gate.
+     */
+    async meetingsTranscriptsList(requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "meetings.transcripts.list.request" },
+            responseType: "meetings.transcripts.list.response",
+        });
+        return payload.records;
+    }
+    async meetingsTranscriptsCreate(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "meetings.transcripts.create.request", ...input },
+            responseType: "meetings.transcripts.create.response",
+        });
+        return payload.record;
+    }
+    async meetingsTranscriptsUpdate(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "meetings.transcripts.update.request", ...input },
+            responseType: "meetings.transcripts.update.response",
+        });
+        return payload.record;
+    }
+    async meetingsTranscriptsDelete(id, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "meetings.transcripts.delete.request", id },
+            responseType: "meetings.transcripts.delete.response",
+        });
+        return payload.deleted;
+    }
+    /**
+     * Read daemon-owned connection metadata for reusable integration settings.
+     * Requires server_info.features.integrationAuthorization; callers own that
+     * one capability gate.
+     */
+    async integrationsAuthorizationGetOverview(requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "integrations.authorization.get_overview.request" },
+            responseType: "integrations.authorization.get_overview.response",
+        });
+        return payload.overview;
+    }
+    /**
+     * List the daemon's nonsecret authorization choices for an integration.
+     * Requires server_info.features.integrationAuthorization; callers own that
+     * one capability gate.
+     */
+    async integrationsAuthorizationGetMethods(integrationId, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "integrations.authorization.get_methods.request",
+                ...(integrationId ? { integrationId } : {}),
+            },
+            responseType: "integrations.authorization.get_methods.response",
+        });
+        return payload.methods;
+    }
+    /**
+     * Starts a daemon-owned browser sign-in through a registered integration
+     * driver. Requires server_info.features.integrationAuthorizationBrowserFlow;
+     * callers own that one capability gate.
+     */
+    async integrationsAuthorizationStartBrowser(input, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "integrations.authorization.start_browser.request", ...input },
+            responseType: "integrations.authorization.start_browser.response",
+        });
+    }
+    /** Starts the daemon-owned Zoom Team Chat browser sign-in. */
+    async integrationsZoomStartAuthorization(requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "integrations.zoom.start_authorization.request" },
+            responseType: "integrations.zoom.start_authorization.response",
+        });
+    }
     /**
      * The brain's status. Pass `resources` only from a surface that renders the
      * live CPU/RAM/GPU numbers: it costs an `nvidia-smi` spawn on the brain, and
@@ -4600,7 +4978,7 @@ export class DaemonClient {
         }
         return payload.runtimes;
     }
-    async brainModelsPull(model, componentsOrRequestId, quantOrRequestId) {
+    async brainModelsPull(model, componentsOrRequestId, quantOrRequestId, expectedBytes) {
         const components = Array.isArray(componentsOrRequestId) ? componentsOrRequestId : undefined;
         const quant = Array.isArray(componentsOrRequestId) ? quantOrRequestId : undefined;
         const correlationId = typeof componentsOrRequestId === "string" ? componentsOrRequestId : undefined;
@@ -4611,6 +4989,7 @@ export class DaemonClient {
                 model,
                 ...(components ? { components } : {}),
                 ...(quant ? { quant } : {}),
+                ...(expectedBytes !== undefined ? { expectedBytes } : {}),
             },
             responseType: "brain.models.pull.response",
         });
@@ -4638,10 +5017,16 @@ export class DaemonClient {
         }
         return payload.quants;
     }
-    async brainModelsAdd(repo, quant, components, requestId) {
+    async brainModelsAdd(repo, quant, components, requestId, expectedBytes) {
         const payload = await this.sendCorrelatedSessionRequest({
             requestId,
-            message: { type: "brain.models.add.request", repo, quant, components },
+            message: {
+                type: "brain.models.add.request",
+                repo,
+                quant,
+                components,
+                ...(expectedBytes !== undefined ? { expectedBytes } : {}),
+            },
             responseType: "brain.models.add.response",
         });
         return unwrapBrainJob(payload);
@@ -4686,6 +5071,31 @@ export class DaemonClient {
         });
         return unwrapBrainJob(payload);
     }
+    async createFileEntry(input) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "fs.entry.create.request", ...input },
+        });
+    }
+    async renameFileEntry(input) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "fs.entry.rename.request", ...input },
+        });
+    }
+    async duplicateFileEntry(input) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "fs.entry.duplicate.request", ...input },
+        });
+    }
+    async deleteFileEntry(input) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "fs.entry.delete.request", ...input },
+        });
+    }
+    async checkoutDiscardChanges(cwd, input) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "checkout.discard_changes.request", cwd, paths: input.paths },
+        });
+    }
     async brainJobsList(requestId) {
         const payload = await this.sendCorrelatedSessionRequest({
             requestId,
@@ -4801,6 +5211,15 @@ export class DaemonClient {
         }
         return payload.status;
     }
+    async getProjectIcon(projectId, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: { type: "project.icon.get.request", projectId },
+        });
+    }
+    // ============================================================================
+    // Provider Models / Commands
+    // ============================================================================
     /** Delete a model's files. The brain refuses while that model is loaded. */
     async brainModelDelete(modelId, requestId) {
         const payload = await this.sendCorrelatedSessionRequest({
@@ -4862,6 +5281,21 @@ export class DaemonClient {
         }
         return payload;
     }
+    /**
+     * Turn the live Brain log feed on or off for this socket.
+     *
+     * Only meaningful against a daemon advertising `features.brainLogWatch`; older
+     * daemons push every line regardless, and the request would go unrouted.
+     * Watching is per socket, so this does not affect the same account's other
+     * connected clients.
+     */
+    async brainLogsWatch(watching, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.logs.watch.request", watching },
+            responseType: "brain.logs.watch.response",
+        });
+    }
     async getSpeechSettingsOptions(requestId) {
         return this.sendNamespacedCorrelatedSessionRequest({
             requestId,
@@ -5382,86 +5816,6 @@ export class DaemonClient {
             responseType: "terminal.compatibility.diagnostic.response",
         });
     }
-    async createChatRoom(options) {
-        return this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "chat/create",
-                name: options.name,
-                ...(options.purpose ? { purpose: options.purpose } : {}),
-            },
-            responseType: "chat/create/response",
-        });
-    }
-    async listChatRooms(requestId) {
-        return this.sendCorrelatedSessionRequest({
-            requestId,
-            message: {
-                type: "chat/list",
-            },
-            responseType: "chat/list/response",
-        });
-    }
-    async inspectChatRoom(options) {
-        return this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "chat/inspect",
-                room: options.room,
-            },
-            responseType: "chat/inspect/response",
-        });
-    }
-    async deleteChatRoom(options) {
-        return this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "chat/delete",
-                room: options.room,
-            },
-            responseType: "chat/delete/response",
-        });
-    }
-    async postChatMessage(options) {
-        return this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "chat/post",
-                room: options.room,
-                body: options.body,
-                ...(options.authorAgentId ? { authorAgentId: options.authorAgentId } : {}),
-                ...(options.replyToMessageId ? { replyToMessageId: options.replyToMessageId } : {}),
-            },
-            responseType: "chat/post/response",
-        });
-    }
-    async readChatMessages(options) {
-        return this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "chat/read",
-                room: options.room,
-                ...(typeof options.limit === "number" ? { limit: options.limit } : {}),
-                ...(options.since ? { since: options.since } : {}),
-                ...(options.authorAgentId ? { authorAgentId: options.authorAgentId } : {}),
-            },
-            responseType: "chat/read/response",
-            timeout: options.timeout,
-        });
-    }
-    async waitForChatMessages(options) {
-        return this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "chat/wait",
-                room: options.room,
-                ...(options.afterMessageId ? { afterMessageId: options.afterMessageId } : {}),
-                ...(typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : {}),
-            },
-            responseType: "chat/wait/response",
-            timeout: (options.timeoutMs ?? 0) + 10000,
-        });
-    }
     async scheduleCreate(options) {
         return this.sendCorrelatedSessionRequest({
             requestId: options.requestId,
@@ -5661,76 +6015,6 @@ export class DaemonClient {
             responseType: "artifact.get-content.response",
         });
     }
-    async loopRun(options) {
-        return this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "loop/run",
-                prompt: options.prompt,
-                cwd: options.cwd,
-                ...(options.provider ? { provider: options.provider } : {}),
-                ...(options.model ? { model: options.model } : {}),
-                ...(options.modeId ? { modeId: options.modeId } : {}),
-                ...(options.verifierProvider ? { verifierProvider: options.verifierProvider } : {}),
-                ...(options.verifierModel ? { verifierModel: options.verifierModel } : {}),
-                ...(options.verifierModeId ? { verifierModeId: options.verifierModeId } : {}),
-                ...(options.verifyPrompt ? { verifyPrompt: options.verifyPrompt } : {}),
-                ...(options.verifyChecks && options.verifyChecks.length > 0
-                    ? { verifyChecks: options.verifyChecks }
-                    : {}),
-                ...(options.name ? { name: options.name } : {}),
-                ...(typeof options.sleepMs === "number" ? { sleepMs: options.sleepMs } : {}),
-                ...(typeof options.maxIterations === "number"
-                    ? { maxIterations: options.maxIterations }
-                    : {}),
-                ...(typeof options.maxTimeMs === "number" ? { maxTimeMs: options.maxTimeMs } : {}),
-            },
-            responseType: "loop/run/response",
-        });
-    }
-    async loopList(requestId) {
-        return this.sendCorrelatedSessionRequest({
-            requestId,
-            message: {
-                type: "loop/list",
-            },
-            responseType: "loop/list/response",
-        });
-    }
-    async loopInspect(options) {
-        const normalized = typeof options === "string" ? { id: options } : options;
-        return this.sendCorrelatedSessionRequest({
-            requestId: normalized.requestId,
-            message: {
-                type: "loop/inspect",
-                id: normalized.id,
-            },
-            responseType: "loop/inspect/response",
-        });
-    }
-    async loopLogs(options, afterSeq) {
-        const normalized = typeof options === "string" ? { id: options, afterSeq } : options;
-        return this.sendCorrelatedSessionRequest({
-            requestId: normalized.requestId,
-            message: {
-                type: "loop/logs",
-                id: normalized.id,
-                ...(typeof normalized.afterSeq === "number" ? { afterSeq: normalized.afterSeq } : {}),
-            },
-            responseType: "loop/logs/response",
-        });
-    }
-    async loopStop(options) {
-        const normalized = typeof options === "string" ? { id: options } : options;
-        return this.sendCorrelatedSessionRequest({
-            requestId: normalized.requestId,
-            message: {
-                type: "loop/stop",
-                id: normalized.id,
-            },
-            responseType: "loop/stop/response",
-        });
-    }
     onTerminalStreamEvent(handler) {
         return this.terminalStreams.onEvent(handler);
     }
@@ -5784,7 +6068,7 @@ export class DaemonClient {
             return;
         }
         try {
-            this.transport.send(JSON.stringify({
+            this.sendJsonMessage("hello", "hello", {
                 type: "hello",
                 clientId: this.config.clientId,
                 clientType: this.config.clientType ?? "cli",
@@ -5797,10 +6081,12 @@ export class DaemonClient {
                     // The daemon gates project.updated.notification on this (session.ts),
                     // so dropping it silently kills cross-session project renames.
                     [CLIENT_CAPS.projectUpdates]: true,
+                    [CLIENT_CAPS.communicationsPresenceUpdates]: true,
+                    [CLIENT_CAPS.compactProviderSnapshots]: true,
                     ...this.config.capabilities,
                 },
                 ...(this.config.appVersion ? { appVersion: this.config.appVersion } : {}),
-            }));
+            });
         }
         catch (error) {
             const message = error instanceof Error ? error.message : "Failed to send hello message";
@@ -5865,25 +6151,37 @@ export class DaemonClient {
             return;
         }
         const rawBytes = asUint8Array(rawData);
-        if (rawBytes && this.tryHandleBinaryFrame(rawBytes)) {
-            return;
+        const isOpen = this.beginTraceSection("otto.ws.frame.inbound", describeInboundTransportFrame(rawData, rawBytes));
+        try {
+            if (rawBytes && this.tryHandleBinaryFrame(rawBytes)) {
+                return;
+            }
+            const payload = decodeMessageData(rawData);
+            if (!payload) {
+                return;
+            }
+            this.handleJsonPayload(payload, rawBytes?.byteLength);
         }
-        const payload = decodeMessageData(rawData);
-        if (!payload) {
-            return;
+        finally {
+            this.endTraceSection(isOpen);
         }
-        this.handleJsonPayload(payload, rawBytes?.byteLength);
     }
     handleJsonPayload(payload, rawBytesLength) {
         const bytes = rawBytesLength ?? payload.length;
         const startMs = perfNow();
         let parsedJson;
+        const parseTraceOpen = this.beginTraceSection("otto.ws.json.parse", {
+            size: String(bytes),
+        });
         try {
             parsedJson = JSON.parse(payload);
         }
         catch {
             return;
         }
+        finally {
+            this.endTraceSection(parseTraceOpen);
+        }
         const parsed = validateWSOutboundMessage(parsedJson);
         if (!parsed.success) {
             const responseIdentity = extractCorrelatedResponseIdentity(parsedJson);
@@ -5902,10 +6200,18 @@ export class DaemonClient {
         }
         this.consecutiveLivenessFailures = 0;
         if (parsed.data.type === "pong") {
+            this.traceInstant("otto.ws.message.inbound", {
+                envelopeType: "pong",
+                messageType: "pong",
+            });
             this.resolvePingProbe();
             this.runtimeMetrics?.recordMessage("pong", bytes, perfNow() - startMs);
             return;
         }
+        this.traceInstant("otto.ws.message.inbound", {
+            envelopeType: "session",
+            messageType: parsed.data.message.type,
+        });
         this.handleSessionMessage(parsed.data.message);
         const msgType = parsed.data.message.type;
         this.runtimeMetrics?.recordMessage(msgType, bytes, perfNow() - startMs);
@@ -5916,6 +6222,11 @@ export class DaemonClient {
     tryHandleBinaryFrame(rawBytes) {
         const fileFrame = decodeFileTransferFrame(rawBytes);
         if (fileFrame) {
+            this.traceInstant("otto.ws.message.inbound", {
+                envelopeType: "binary",
+                messageType: "file",
+                opcode: String(fileFrame.opcode),
+            });
             this.consecutiveLivenessFailures = 0;
             this.handleFileTransferFrame(fileFrame);
             this.runtimeMetrics?.recordBinaryFrame("other", rawBytes.byteLength, 0);
@@ -5925,6 +6236,11 @@ export class DaemonClient {
         if (!frame) {
             return false;
         }
+        this.traceInstant("otto.ws.message.inbound", {
+            envelopeType: "binary",
+            messageType: "terminal",
+            opcode: String(frame.opcode),
+        });
         this.consecutiveLivenessFailures = 0;
         const binaryStartMs = perfNow();
         this.terminalStreams.handleFrame(frame);