@otto-code/client 0.7.4 → 0.7.6

package/dist/daemon-client.js

@@ -57,6 +57,16 @@ class DaemonRpcError extends Error {
         this.code = params.code;
     }
 }
+class DaemonProtocolError extends Error {
+    constructor(identity) {
+        const responseLabel = identity.responseType ?? "unknown response";
+        super(`Response validation failed for ${responseLabel}`);
+        this.code = "invalid_response";
+        this.name = "DaemonProtocolError";
+        this.requestId = identity.requestId;
+        this.responseType = identity.responseType;
+    }
+}
 class PingTimeoutError extends Error {
     constructor(timeoutMs) {
         super(`Ping timed out (${timeoutMs}ms)`);
@@ -64,6 +74,40 @@ class PingTimeoutError extends Error {
         this.name = "PingTimeoutError";
     }
 }
+/**
+ * Pull the request correlation out of a frame that failed schema validation.
+ * Reads only the envelope and `payload.requestId`, which is exactly the part a
+ * malformed response still gets right, so the waiting caller can be failed with
+ * a real reason rather than left to time out.
+ */
+function extractCorrelatedResponseIdentity(input) {
+    if (!input || typeof input !== "object") {
+        return null;
+    }
+    const envelope = input;
+    if (envelope.type !== "session" || !envelope.message || typeof envelope.message !== "object") {
+        return null;
+    }
+    const message = envelope.message;
+    if (typeof message.type !== "string" ||
+        !(message.type === "rpc_error" ||
+            message.type.endsWith("_response") ||
+            message.type.endsWith(".response") ||
+            message.type.endsWith("/response"))) {
+        return null;
+    }
+    if (!message.payload || typeof message.payload !== "object") {
+        return null;
+    }
+    const payload = message.payload;
+    if (typeof payload.requestId !== "string") {
+        return null;
+    }
+    return {
+        requestId: payload.requestId,
+        responseType: message.type,
+    };
+}
 function toTimeoutError(error, label, timeoutMs) {
     if (error instanceof PingTimeoutError) {
         return new Error(`${label} timed out (${timeoutMs}ms)`);
@@ -120,6 +164,7 @@ function legacyExplorerFileToBytes(file) {
         kind: file.kind,
         modifiedAt: file.modifiedAt,
         eol: file.eol,
+        revision: file.revision,
     };
 }
 function binaryFileKind(mime, encoding) {
@@ -169,6 +214,20 @@ function toReasonCode(reason) {
     }
     return "unknown";
 }
+// A job-starting brain RPC returns { job, error }; surface the error as a throw
+// so callers get a plain Promise<BrainJob>.
+function unwrapBrainJob(payload) {
+    if (payload.error) {
+        throw new Error(payload.error);
+    }
+    if (!payload.job) {
+        throw new Error("The brain did not start the operation.");
+    }
+    return payload.job;
+}
+// A repo clone can take minutes on a large history, so it gets its own budget
+// rather than the default request timeout.
+const PROJECT_GITHUB_CLONE_TIMEOUT_MS = 5 * 60 * 1000;
 export class DaemonClient {
     constructor(config) {
         this.config = config;
@@ -192,6 +251,7 @@ export class DaemonClient {
         this.connectionState = { status: "idle" };
         this.checkoutDiffSubscriptions = new Map();
         this.terminalDirectorySubscriptions = new Map();
+        this.fileSubscriptions = new Map();
         this.terminalStreams = new TerminalStreamRouter();
         // requestId -> progress listener for an in-flight project.scaffold.request.
         // Entries are always removed in scaffoldProject's finally block.
@@ -659,7 +719,7 @@ export class DaemonClient {
                 return null;
             }
             return { kind: "ok", value };
-        }, timeout, params.options);
+        }, timeout, { ...params.options, requestId: params.requestId });
         try {
             await this.sendSessionMessageOrThrow(params.message);
         }
@@ -1265,6 +1325,7 @@ export class DaemonClient {
             ...(options.personality ? { personality: options.personality } : {}),
             ...(options.env ? { env: options.env } : {}),
             ...(options.workspaceId !== undefined ? { workspaceId: options.workspaceId } : {}),
+            ...(options.callerAgentId !== undefined ? { callerAgentId: options.callerAgentId } : {}),
             ...(options.initialPrompt ? { initialPrompt: options.initialPrompt } : {}),
             ...(options.clientMessageId ? { clientMessageId: options.clientMessageId } : {}),
             ...(options.outputSchema ? { outputSchema: options.outputSchema } : {}),
@@ -1842,6 +1903,266 @@ export class DaemonClient {
             },
         });
     }
+    async listProviderSubagents(parentAgentId, options = {}) {
+        const requestId = this.createRequestId(options.requestId);
+        const message = SessionInboundMessageSchema.parse({
+            type: "agent.provider_subagents.list.request",
+            parentAgentId,
+            requestId,
+        });
+        const payload = await this.sendRequest({
+            requestId,
+            message,
+            timeout: options.timeout,
+            options: { skipQueue: true },
+            select: (response) => response.type === "agent.provider_subagents.list.response" &&
+                response.payload.requestId === requestId
+                ? response.payload
+                : null,
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload;
+    }
+    async fetchProviderSubagentTimeline(parentAgentId, subagentId, options = {}) {
+        const requestId = this.createRequestId(options.requestId);
+        const message = SessionInboundMessageSchema.parse({
+            type: "agent.provider_subagents.timeline.get.request",
+            parentAgentId,
+            subagentId,
+            requestId,
+            ...(options.direction ? { direction: options.direction } : {}),
+            ...(options.cursor ? { cursor: options.cursor } : {}),
+            ...(typeof options.limit === "number" ? { limit: options.limit } : {}),
+        });
+        const payload = await this.sendRequest({
+            requestId,
+            message,
+            timeout: options.timeout,
+            options: { skipQueue: true },
+            select: (response) => response.type === "agent.provider_subagents.timeline.get.response" &&
+                response.payload.requestId === requestId
+                ? response.payload
+                : null,
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload;
+    }
+    async checkoutForgeGetCheckDetails(input, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "checkout.forge.get_check_details.request",
+                cwd: input.cwd,
+                repoOwner: input.repoOwner,
+                repoName: input.repoName,
+                checkRunId: input.checkRunId,
+                workflowRunId: input.workflowRunId,
+                changeRequestNumber: input.changeRequestNumber,
+            },
+            timeout: 60000,
+        });
+    }
+    async checkoutForgeSetAutoMerge(cwd, input, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "checkout.forge.set_auto_merge.request",
+                cwd,
+                enabled: input.enabled,
+                ...(input.enabled ? { mergeMethod: input.method } : {}),
+            },
+            timeout: 60000,
+        });
+    }
+    async createProjectDirectory(input, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "project.create_directory.request",
+                parentPath: input.parentPath,
+                name: input.name,
+            },
+        });
+    }
+    async getCommitFileDiff(cwd, sha, path, requestId) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "checkout.commits.file_diff.request",
+                cwd,
+                sha,
+                path,
+            },
+            timeout: 60000,
+        });
+        if (payload.error) {
+            throw new Error(payload.error.message);
+        }
+        return { file: payload.file };
+    }
+    async inspectWorkspaceRecovery(workspaceId, requestId) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "workspace.recovery.inspect.request",
+                workspaceId,
+            },
+        });
+        return payload.state;
+    }
+    async listCheckoutCommits(cwd, requestId) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "checkout.commits.list.request",
+                cwd,
+            },
+            timeout: 60000,
+        });
+        if (payload.error) {
+            throw new Error(payload.error.message);
+        }
+        return { baseRef: payload.baseRef, commits: payload.commits };
+    }
+    async listProjects(requestId) {
+        const resolvedRequestId = this.createRequestId(requestId);
+        const message = SessionInboundMessageSchema.parse({
+            type: "project.list.request",
+            requestId: resolvedRequestId,
+        });
+        return this.sendRequest({
+            requestId: resolvedRequestId,
+            message,
+            options: { skipQueue: true },
+            select: (msg) => {
+                if (msg.type !== "project.list.response")
+                    return null;
+                if (msg.payload.requestId !== resolvedRequestId)
+                    return null;
+                return msg.payload;
+            },
+        });
+    }
+    onAgentAttentionRequired(handler) {
+        const unsubscribeLegacy = this.on("agent_stream", (message) => {
+            if (message.payload.event.type !== "attention_required") {
+                return;
+            }
+            const event = message.payload.event;
+            handler({
+                agentId: message.payload.agentId,
+                reason: event.reason,
+                timestamp: event.timestamp,
+                shouldNotify: event.shouldNotify,
+                ...(event.notification ? { notification: event.notification } : {}),
+            });
+        });
+        const unsubscribeDedicated = this.on("agent_attention_required", (message) => {
+            handler(message.payload);
+        });
+        return () => {
+            unsubscribeLegacy();
+            unsubscribeDedicated();
+        };
+    }
+    async restoreWorkspace(workspaceId, requestId) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "workspace.recovery.restore.request",
+                workspaceId,
+            },
+            timeout: 150000,
+        });
+        if (!payload.accepted) {
+            throw new Error(payload.error ?? "Workspace recovery was rejected by the host");
+        }
+    }
+    async searchGithubRepositories(input, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "workspace.github.search_repositories.request",
+                query: input.query,
+                limit: input.limit,
+            },
+        });
+    }
+    async setAgentTimelineSubscription(agentIds) {
+        // COMPAT(selectiveAgentTimeline): added in v0.1.106. Old daemons keep their
+        // legacy global stream and do not understand this RPC. Remove after
+        // 2027-01-12 once the supported daemon floor is >= v0.1.106.
+        if (!this.lastServerInfoMessage?.features?.selectiveAgentTimeline) {
+            return;
+        }
+        const requestId = this.createRequestId();
+        const normalizedAgentIds = [...new Set(agentIds)].sort();
+        const message = SessionInboundMessageSchema.parse({
+            type: "agent.timeline.set_subscription.request",
+            agentIds: normalizedAgentIds,
+            requestId,
+        });
+        await this.sendRequest({
+            requestId,
+            message,
+            options: { skipQueue: true },
+            select: (response) => {
+                if (response.type !== "agent.timeline.set_subscription.response") {
+                    return null;
+                }
+                return response.payload.requestId === requestId ? response.payload : null;
+            },
+        });
+    }
+    async setWorkspacePinned(workspaceId, pinned, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "workspace.pin.set.request",
+                workspaceId,
+                pinned,
+            },
+            responseType: "workspace.pin.set.response",
+        });
+        if (!payload.accepted) {
+            throw new Error(payload.error ?? "setWorkspacePinned rejected");
+        }
+        return { pinnedAt: payload.pinnedAt };
+    }
+    async subscribeFile(input, onUpdate) {
+        const subscriptionId = this.createRequestId();
+        this.fileSubscriptions.set(subscriptionId, { ...input, onUpdate });
+        try {
+            const payload = await this.sendCorrelatedSessionRequest({
+                message: {
+                    type: "fs.file.subscribe.request",
+                    cwd: input.cwd,
+                    path: input.path,
+                    subscriptionId,
+                },
+                responseType: "fs.file.subscribe.response",
+            });
+            return {
+                initial: payload.initial,
+                unsubscribe: () => {
+                    if (!this.fileSubscriptions.delete(subscriptionId))
+                        return;
+                    void this.sendCorrelatedSessionRequest({
+                        message: { type: "fs.file.unsubscribe.request", subscriptionId },
+                        responseType: "fs.file.unsubscribe.response",
+                    }).catch(() => undefined);
+                },
+            };
+        }
+        catch (error) {
+            this.fileSubscriptions.delete(subscriptionId);
+            throw error;
+        }
+    }
     async fetchAgentTimeline(agentId, options = {}) {
         const resolvedRequestId = this.createRequestId(options.requestId);
         const message = SessionInboundMessageSchema.parse({
@@ -1879,6 +2200,7 @@ export class DaemonClient {
             type: "agent.fork_context.request",
             agentId,
             requestId: resolvedRequestId,
+            ...(options.boundaryCursor ? { boundaryCursor: options.boundaryCursor } : {}),
             ...(options.boundaryMessageId ? { boundaryMessageId: options.boundaryMessageId } : {}),
         });
         const payload = await this.sendRequest({
@@ -2084,6 +2406,13 @@ export class DaemonClient {
                 return msg.payload;
             },
         });
+        // A refused cancellation comes back as an error payload, not a rejected
+        // frame. Dropping it reported Stop as successful while the provider was
+        // still running and still spending tokens — the exact outcome the daemon
+        // refuses the cancel to avoid.
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
         // Absent ⇒ old daemon that doesn't report whether a run was interrupted.
         return payload.cancelled !== undefined ? { cancelled: payload.cancelled } : {};
     }
@@ -2139,6 +2468,7 @@ export class DaemonClient {
         if (!payload.accepted) {
             throw new Error(payload.error ?? "setAgentModel rejected");
         }
+        return payload.notice ?? null;
     }
     async setAgentFeature(agentId, featureId, value) {
         const requestId = this.createRequestId();
@@ -3038,6 +3368,20 @@ export class DaemonClient {
             responseType: "branch_suggestions_response",
         });
     }
+    async searchForge(options, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "forge.search.request",
+                cwd: options.cwd,
+                query: options.query,
+                limit: options.limit,
+                kinds: options.kinds,
+            },
+            responseType: "forge.search.response",
+            timeout: 15000,
+        });
+    }
     async searchGitHub(options, requestId) {
         return this.sendCorrelatedSessionRequest({
             requestId,
@@ -3172,6 +3516,18 @@ export class DaemonClient {
             hash: file.hash ?? null,
         };
     }
+    /**
+     * The fs.file.write RPC: optimistic-concurrency writes keyed by an opaque
+     * revision. The hash-keyed `writeFile` below is kept for callers
+     * that have not moved over.
+     */
+    async writeFsFile(input) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            message: { type: "fs.file.write.request", ...input },
+            responseType: "fs.file.write.response",
+        });
+        return payload.result;
+    }
     /** Conditional save — see FileWriteRequestSchema for the no-clobber contract. */
     async writeFile(options) {
         const payload = await this.sendCorrelatedSessionRequest({
@@ -3190,6 +3546,73 @@ export class DaemonClient {
         });
         return payload.result;
     }
+    /**
+     * Write bytes to a workspace file — the path for generated artifacts the
+     * text write cannot carry (it refuses binary targets outright). Gated on
+     * `features.binaryFileWrite`; there is no client-side substitute, because
+     * the client never touches a workspace file on any platform.
+     *
+     * Shaped like {@link uploadFile}: the JSON request says where the bytes go
+     * and how many to expect, then the bytes follow as file-transfer frames
+     * correlated on the same `requestId`. The daemon answers at FileEnd.
+     */
+    async writeBinaryFile(options) {
+        const bytes = asUint8Array(options.bytes);
+        if (!bytes) {
+            throw new Error("File bytes are required.");
+        }
+        const resolvedRequestId = this.createRequestId(options.requestId);
+        const responsePromise = this.sendCorrelatedSessionRequest({
+            requestId: resolvedRequestId,
+            message: {
+                type: "fs.file.write_binary.request",
+                cwd: options.cwd,
+                path: options.path,
+                size: bytes.byteLength,
+                overwrite: options.overwrite,
+            },
+            responseType: "fs.file.write_binary.response",
+        });
+        this.sendFileTransfer({
+            requestId: resolvedRequestId,
+            bytes,
+            // Nothing downstream reads the mime for a workspace write — the path
+            // decides what the file is — but the frame metadata requires one.
+            mime: "application/octet-stream",
+            chunkSize: options.chunkSize,
+        });
+        const payload = await responsePromise;
+        return payload.result;
+    }
+    /**
+     * FileBegin, chunks, FileEnd. Synchronous through `sendBinaryFrame`, so the
+     * frames leave in order and behind the JSON request that announced them.
+     */
+    sendFileTransfer(input) {
+        this.sendBinaryFrame(encodeFileTransferFrame({
+            opcode: FileTransferOpcode.FileBegin,
+            requestId: input.requestId,
+            metadata: {
+                mime: input.mime,
+                size: input.bytes.byteLength,
+                encoding: "binary",
+                modifiedAt: input.modifiedAt ?? new Date().toISOString(),
+                ...(input.fileName ? { fileName: input.fileName } : {}),
+            },
+        }));
+        const chunkSize = input.chunkSize ?? 1024 * 1024;
+        for (let offset = 0; offset < input.bytes.byteLength; offset += chunkSize) {
+            this.sendBinaryFrame(encodeFileTransferFrame({
+                opcode: FileTransferOpcode.FileChunk,
+                requestId: input.requestId,
+                payload: input.bytes.subarray(offset, Math.min(offset + chunkSize, input.bytes.byteLength)),
+            }));
+        }
+        this.sendBinaryFrame(encodeFileTransferFrame({
+            opcode: FileTransferOpcode.FileEnd,
+            requestId: input.requestId,
+        }));
+    }
     /** Create an empty file or a directory. Never overwrites — see FileCreateResultSchema. */
     async createFileEntry(options) {
         const payload = await this.sendCorrelatedSessionRequest({
@@ -3595,7 +4018,7 @@ export class DaemonClient {
      * torn down when the last disposer runs; events fan out to every caller.
      */
     watchFile(cwd, path, onEvent) {
-        const key = `${cwd}${path}`;
+        const key = `${cwd}${path}`;
         const offMessage = this.on("file.watch.event", (message) => {
             if (message.type !== "file.watch.event") {
                 return;
@@ -3654,29 +4077,14 @@ export class DaemonClient {
             responseType: "file.upload.response",
             options: { skipQueue: true },
         });
-        this.sendBinaryFrame(encodeFileTransferFrame({
-            opcode: FileTransferOpcode.FileBegin,
+        this.sendFileTransfer({
             requestId: resolvedRequestId,
-            metadata: {
-                mime: input.mimeType,
-                size: bytes.byteLength,
-                encoding: "binary",
-                modifiedAt,
-                fileName: input.fileName,
-            },
-        }));
-        const chunkSize = input.chunkSize ?? 1024 * 1024;
-        for (let offset = 0; offset < bytes.byteLength; offset += chunkSize) {
-            this.sendBinaryFrame(encodeFileTransferFrame({
-                opcode: FileTransferOpcode.FileChunk,
-                requestId: resolvedRequestId,
-                payload: bytes.subarray(offset, Math.min(offset + chunkSize, bytes.byteLength)),
-            }));
-        }
-        this.sendBinaryFrame(encodeFileTransferFrame({
-            opcode: FileTransferOpcode.FileEnd,
-            requestId: resolvedRequestId,
-        }));
+            bytes,
+            mime: input.mimeType,
+            fileName: input.fileName,
+            modifiedAt,
+            ...(input.chunkSize === undefined ? {} : { chunkSize: input.chunkSize }),
+        });
         return responsePromise;
     }
     async requestDownloadToken(cwd, path, requestId) {
@@ -3937,6 +4345,249 @@ export class DaemonClient {
             responseType: "set_daemon_config_response",
         });
     }
+    // Enumerate a connector's tools live (connect + listTools), each flagged with
+    // its configured disabled state. Registry edits (add/enable/disable a
+    // connector or a tool) go through patchDaemonConfig's `connectors` instead.
+    async connectorsListTools(connectorId, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "connectors.list_tools.request",
+                connectorId,
+            },
+            responseType: "connectors.list_tools.response",
+        });
+    }
+    async brainHostStatus(requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "brain.host.status.request",
+            },
+            responseType: "brain.host.status.response",
+        });
+        return payload.status;
+    }
+    async brainHostStart(model, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "brain.host.start.request",
+                model: model ?? null,
+            },
+            responseType: "brain.host.start.response",
+        });
+        return payload.status;
+    }
+    async brainHostStop(requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "brain.host.stop.request",
+            },
+            responseType: "brain.host.stop.response",
+        });
+        return payload.status;
+    }
+    async brainHostRestart(model, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "brain.host.restart.request",
+                model: model ?? null,
+            },
+            responseType: "brain.host.restart.response",
+        });
+        return payload.status;
+    }
+    async brainEvalsGet(requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "brain.evals.get.request",
+            },
+            responseType: "brain.evals.get.response",
+        });
+        return payload.evals;
+    }
+    async brainRemoteConfigGet(requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "brain.remote.config.get.request",
+            },
+            responseType: "brain.remote.config.get.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload.config;
+    }
+    async brainRemoteConfigPatch(patch, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "brain.remote.config.patch.request",
+                patch,
+            },
+            responseType: "brain.remote.config.patch.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload.config;
+    }
+    async brainModelsList(requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "brain.models.list.request",
+            },
+            responseType: "brain.models.list.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload.models;
+    }
+    async brainNetworkDiscover(requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "brain.network.discover.request",
+            },
+            responseType: "brain.network.discover.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload.info;
+    }
+    async brainModelsScan(requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.models.scan.request" },
+            responseType: "brain.models.scan.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload.models;
+    }
+    async brainCatalogList(requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.catalog.list.request" },
+            responseType: "brain.catalog.list.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload.models;
+    }
+    async brainRuntimeList(requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.runtime.list.request" },
+            responseType: "brain.runtime.list.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload.runtimes;
+    }
+    async brainModelsPull(model, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.models.pull.request", model },
+            responseType: "brain.models.pull.response",
+        });
+        return unwrapBrainJob(payload);
+    }
+    async brainHfSearch(query, limit, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.hf.search.request", query, limit: limit ?? null },
+            responseType: "brain.hf.search.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload.results;
+    }
+    async brainHfQuants(repo, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.hf.quants.request", repo },
+            responseType: "brain.hf.quants.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload.quants;
+    }
+    async brainModelsAdd(repo, quant, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.models.add.request", repo, quant },
+            responseType: "brain.models.add.response",
+        });
+        return unwrapBrainJob(payload);
+    }
+    async brainRuntimeInstall(build, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.runtime.install.request", build: build ?? null },
+            responseType: "brain.runtime.install.response",
+        });
+        return unwrapBrainJob(payload);
+    }
+    async brainCalibrate(model, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.calibrate.request", model },
+            responseType: "brain.calibrate.response",
+        });
+        return unwrapBrainJob(payload);
+    }
+    async brainSweep(model, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.sweep.request", model },
+            responseType: "brain.sweep.response",
+        });
+        return unwrapBrainJob(payload);
+    }
+    async brainBench(model, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.bench.request", model: model ?? null },
+            responseType: "brain.bench.response",
+        });
+        return unwrapBrainJob(payload);
+    }
+    async brainJobsList(requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.jobs.list.request" },
+            responseType: "brain.jobs.list.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload.jobs;
+    }
+    async brainJobsCancel(jobId, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.jobs.cancel.request", jobId },
+            responseType: "brain.jobs.cancel.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload.jobs;
+    }
     async getSpeechSettingsOptions(requestId) {
         return this.sendNamespacedCorrelatedSessionRequest({
             requestId,
@@ -4007,6 +4658,25 @@ export class DaemonClient {
             },
         });
     }
+    // Author a personality profile (the prose personality prompt) from a draft's
+    // name, roles, and spinner colors. Routed through the Writer chain; the caller
+    // drops the result into the editor's prompt field.
+    async generatePersonalityProfile(params, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "agentPersonalities.generate_profile.request",
+                name: params.name,
+                ...(params.roles && params.roles.length > 0 ? { roles: params.roles } : {}),
+                ...(params.glowA ? { glowA: params.glowA } : {}),
+                ...(params.glowB ? { glowB: params.glowB } : {}),
+                ...(params.cwd ? { cwd: params.cwd } : {}),
+            },
+            // Same reason as the voice cues: the daemon spawns a structured-generation
+            // agent, and provider SDK cold starts blow past the 60s default.
+            timeout: 180000,
+        });
+    }
     sendBrowserAutomationExecuteResponse(response) {
         this.sendSessionMessageStrict(response);
     }
@@ -4836,6 +5506,10 @@ export class DaemonClient {
                     [CLIENT_CAPS.customModeIcons]: true,
                     [CLIENT_CAPS.reasoningMergeEnum]: true,
                     [CLIENT_CAPS.terminalReflowableSnapshot]: true,
+                    [CLIENT_CAPS.providerSubagents]: true,
+                    // The daemon gates project.updated.notification on this (session.ts),
+                    // so dropping it silently kills cross-session project renames.
+                    [CLIENT_CAPS.projectUpdates]: true,
                     ...this.config.capabilities,
                 },
                 ...(this.config.appVersion ? { appVersion: this.config.appVersion } : {}),
@@ -4925,13 +5599,18 @@ export class DaemonClient {
         }
         const parsed = validateWSOutboundMessage(parsedJson);
         if (!parsed.success) {
-            const msgType = parsedJson != null &&
+            const responseIdentity = extractCorrelatedResponseIdentity(parsedJson);
+            const envelopeType = parsedJson != null &&
                 typeof parsedJson === "object" &&
                 "type" in parsedJson &&
                 typeof parsedJson.type === "string"
                 ? parsedJson.type
                 : "unknown";
+            const msgType = responseIdentity?.responseType ?? envelopeType;
             this.logger.warn({ msgType, error: parsed.error.message }, "Message validation failed");
+            if (responseIdentity) {
+                this.rejectWaitersForRequestId(responseIdentity.requestId, new DaemonProtocolError(responseIdentity));
+            }
             return;
         }
         this.consecutiveLivenessFailures = 0;
@@ -5212,6 +5891,18 @@ export class DaemonClient {
             }
         }
     }
+    rejectWaitersForRequestId(requestId, error) {
+        for (const waiter of Array.from(this.waiters)) {
+            if (waiter.requestId !== requestId) {
+                continue;
+            }
+            this.waiters.delete(waiter);
+            if (waiter.timeoutHandle) {
+                clearTimeout(waiter.timeoutHandle);
+            }
+            waiter.reject(error);
+        }
+    }
     clearWaiters(error) {
         for (const waiter of Array.from(this.waiters)) {
             if (waiter.timeoutHandle) {
@@ -5276,7 +5967,7 @@ export class DaemonClient {
                 return null;
         }
     }
-    waitForWithCancel(predicate, timeout = 30000, _options) {
+    waitForWithCancel(predicate, timeout = 30000, options) {
         // Capture stack trace at call site, not inside setTimeout
         const timeoutError = new Error(`Timeout waiting for message (${timeout}ms)`);
         let waiter = null;
@@ -5309,6 +6000,7 @@ export class DaemonClient {
                 resolve: wrappedResolve,
                 reject: wrappedReject,
                 timeoutHandle,
+                requestId: options?.requestId,
             };
             this.waiters.add(waiter);
         });
@@ -5335,6 +6027,80 @@ export class DaemonClient {
         };
         return { promise, cancel };
     }
+    async cloneGithubProject(input, requestId) {
+        const message = {
+            type: "project.github.clone.request",
+            repo: input.repo,
+            targetDirectory: input.targetDirectory,
+            ...(input.cloneProtocol ? { cloneProtocol: input.cloneProtocol } : {}),
+        };
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message,
+            timeout: PROJECT_GITHUB_CLONE_TIMEOUT_MS,
+        });
+    }
+    /**
+     * `includeDiscovered` also returns the Scripts the workspace's own project
+     * files declare (package.json scripts today), each tagged with its `source`.
+     * Gate it on `server_info.features.workspaceScriptDiscovery` — an older
+     * daemon ignores the flag and answers with the otto.json list only.
+     */
+    async listWorkspaceScripts(workspaceId, options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options?.requestId,
+            message: {
+                type: "workspace.script.list.request",
+                workspaceId,
+                includeDiscovered: options?.includeDiscovered ?? false,
+            },
+            responseType: "workspace.script.list.response",
+        });
+    }
+    async startWorkspaceScriptWithStatus(workspaceId, scriptName, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "workspace.script.start.request", workspaceId, scriptName },
+            responseType: "workspace.script.start.response",
+        });
+    }
+    async stopWorkspaceScript(workspaceId, scriptName, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "workspace.script.stop.request", workspaceId, scriptName },
+            responseType: "workspace.script.stop.response",
+        });
+    }
+    async connectHub(hubUrl, token, requestId) {
+        this.requireHubRelationshipSupport();
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "hub.management.daemon.connect.request", hubUrl, token },
+            responseType: "hub.management.daemon.connect.response",
+        });
+    }
+    async getHubStatus(requestId) {
+        this.requireHubRelationshipSupport();
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "hub.management.daemon.get_status.request" },
+            responseType: "hub.management.daemon.get_status.response",
+        });
+    }
+    async disconnectHub(force = false, requestId) {
+        this.requireHubRelationshipSupport();
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "hub.management.daemon.disconnect.request", force },
+            responseType: "hub.management.daemon.disconnect.response",
+        });
+    }
+    requireHubRelationshipSupport() {
+        // COMPAT(hubRelationship): added in v0.2.5, drop the gate when floor >= v0.2.5.
+        if (this.lastServerInfoMessage?.features?.hubRelationship !== true) {
+            throw new Error("Update the host to use Hub relationship management.");
+        }
+    }
 }
 function resolveAgentConfig(options) {
     const { config, provider, cwd, env: _env, workspaceId: _workspaceId, initialPrompt: _initialPrompt, images: _images, git: _git, worktreeName: _worktreeName, requestId: _requestId, labels: _labels, ...overrides } = options;