@otto-code/client 0.7.5 → 0.8.0

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) {
@@ -180,6 +225,9 @@ function unwrapBrainJob(payload) {
     }
     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;
@@ -203,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.
@@ -244,7 +293,7 @@ export class DaemonClient {
         const runtimeMetricsIntervalMs = typeof config.runtimeMetricsIntervalMs === "number" && config.runtimeMetricsIntervalMs > 0
             ? config.runtimeMetricsIntervalMs
             : 0;
-        // The metrics object is always constructed — it is a handful of Maps keyed
+        // The metrics object is always constructed - it is a handful of Maps keyed
         // by message type, and its per-message cost is dwarfed by the JSON.parse it
         // is measuring. What `runtimeMetricsIntervalMs` gates is the *periodic log*,
         // which is the part that is actually noisy. Keeping the counters on
@@ -670,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);
         }
@@ -1276,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 } : {}),
@@ -1343,7 +1393,7 @@ export class DaemonClient {
      * the whole archived set. Pass `dryRun: true` first to get the count the
      * confirm dialog quotes, then the same call with `dryRun: false` to delete.
      *
-     * Removes Otto's records only — provider transcripts are left on disk. Gated
+     * Removes Otto's records only - provider transcripts are left on disk. Gated
      * by `server_info.features.historyDelete`; there is no fallback path, so check
      * the flag before offering the action.
      */
@@ -1374,7 +1424,7 @@ export class DaemonClient {
      * `dryRun: false` to delete.
      *
      * Cleared images do not come back: a message that referenced one renders its
-     * alt text from then on. Scope is the whole host — filenames are a content
+     * alt text from then on. Scope is the whole host - filenames are a content
      * hash, so per-chat or per-workspace scope does not exist. Gated by
      * `server_info.features.attachmentStorage`.
      */
@@ -1440,7 +1490,7 @@ export class DaemonClient {
     }
     /**
      * Stop a running background shell task (Claude Bash tool run_in_background).
-     * Not an AI subagent — the daemon resolves it to its owning provider task and
+     * Not an AI subagent - the daemon resolves it to its owning provider task and
      * calls the provider's stopTask, same mechanism as stopObservedSubagent.
      */
     async stopBackgroundShellTask(parentAgentId, taskId) {
@@ -1473,7 +1523,7 @@ export class DaemonClient {
     }
     /**
      * Start one or more suggested tasks (from `spawn_task` chips), applying the
-     * same mode to each — a new worktree workspace per task, a new local session
+     * same mode to each - a new worktree workspace per task, a new local session
      * per task, or steering the parent's current session. Individual actions pass
      * a single-element array; the "Start all" collective action passes the whole
      * pending queue. Resolves to the count started; throws only if all failed.
@@ -1541,7 +1591,7 @@ export class DaemonClient {
     }
     /**
      * Orchestration: delete one finished (or draft) run. Throws with the
-     * daemon's reason when it refuses — an active run has to be canceled first.
+     * daemon's reason when it refuses - an active run has to be canceled first.
      */
     async deleteRun(runId) {
         const payload = await this.sendNamespacedCorrelatedSessionRequest({
@@ -1853,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({
@@ -1890,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({
@@ -1987,7 +2298,7 @@ export class DaemonClient {
     }
     /**
      * Move one queued message to a new position. Resolves false when the entry
-     * was already drained or was already there — the authoritative order arrives
+     * was already drained or was already there - the authoritative order arrives
      * on the agent snapshot either way. Requires
      * `server_info.features.steerQueueReorder`.
      */
@@ -2095,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 } : {};
     }
@@ -2150,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();
@@ -2208,7 +2527,7 @@ export class DaemonClient {
     /**
      * Live-switch a running agent's personality (null clears it). The daemon
      * re-resolves the roster id against the agent's cwd and applies the full
-     * personality — system prompt, identity, model/mode/effort — restarting the
+     * personality - system prompt, identity, model/mode/effort - restarting the
      * provider query so the prompt takes effect on the next turn. Gate on
      * server_info.features.setAgentPersonality.
      */
@@ -2300,7 +2619,7 @@ export class DaemonClient {
         return this.sendRequest({
             requestId: resolvedRequestId,
             message,
-            timeout: 300000, // 5 minutes — npm update can be slow on remote machines
+            timeout: 300000, // 5 minutes - npm update can be slow on remote machines
             options: { skipQueue: true },
             select: (msg) => {
                 const parsed = DaemonUpdateResponseSchema.safeParse(msg);
@@ -2698,7 +3017,7 @@ export class DaemonClient {
         });
     }
     // ── Git file investigation ────────────────────────────────────────────────
-    // Local git only: no remote, no forge, and no per-provider variant — the same
+    // Local git only: no remote, no forge, and no per-provider variant - the same
     // four calls answer for every agent provider. Gated by
     // server_info.features.checkoutGitFileHistory.
     async checkoutGitFileHistory(cwd, input, requestId) {
@@ -3049,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,
@@ -3177,13 +3510,25 @@ export class DaemonClient {
             content: file.content,
             size: file.size,
             modifiedAt: file.modifiedAt,
-            // COMPAT(textEditor): added in v0.4.4 — the editor is gated on
+            // COMPAT(textEditor): added in v0.4.4 - the editor is gated on
             // features.textEditor, so a gated daemon always sends both fields.
             eol: file.eol ?? "lf",
             hash: file.hash ?? null,
         };
     }
-    /** Conditional save — see FileWriteRequestSchema for the no-clobber contract. */
+    /**
+     * 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({
             requestId: options.requestId,
@@ -3201,7 +3546,74 @@ export class DaemonClient {
         });
         return payload.result;
     }
-    /** Create an empty file or a directory. Never overwrites — see FileCreateResultSchema. */
+    /**
+     * 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({
             requestId: options.requestId,
@@ -3215,7 +3627,7 @@ export class DaemonClient {
         });
         return payload.result;
     }
-    /** Permanent delete — an unlink, not a move to any trash. */
+    /** Permanent delete - an unlink, not a move to any trash. */
     async deleteFileEntry(options) {
         const payload = await this.sendCorrelatedSessionRequest({
             requestId: options.requestId,
@@ -3337,7 +3749,7 @@ export class DaemonClient {
     }
     /**
      * Mirror the editor's current buffer to the daemon so definitions resolve against
-     * unsaved edits. Debounced by the caller — this is not a per-keystroke RPC.
+     * unsaved edits. Debounced by the caller - this is not a per-keystroke RPC.
      */
     async syncCodeDocument(cwd, path, text, requestId) {
         const payload = await this.sendCorrelatedSessionRequest({
@@ -3401,7 +3813,7 @@ export class DaemonClient {
         return { status: payload.status, locations: payload.locations, error: payload.error };
     }
     /**
-     * A rename **dry run** — every edit it would make, and nothing written. The client
+     * A rename **dry run** - every edit it would make, and nothing written. The client
      * puts this in front of the user as a job to audit before applying.
      */
     async previewCodeRename(input, requestId) {
@@ -3512,7 +3924,7 @@ export class DaemonClient {
      *
      * Never throws and never carries an error the caller has to render. A workspace with no
      * solution, a host with no .NET SDK, and a host with the feature switched off all answer with an
-     * empty list, so the caller has one silent case — "no switcher" — rather than four states.
+     * empty list, so the caller has one silent case - "no switcher" - rather than four states.
      */
     async listSolutions(cwd, requestId) {
         const payload = await this.sendCorrelatedSessionRequest({
@@ -3587,7 +3999,7 @@ export class DaemonClient {
         }
         return payload.symbols;
     }
-    /** Preview-first project replace — see FileReplaceRequestSchema. */
+    /** Preview-first project replace - see FileReplaceRequestSchema. */
     async replaceFiles(options) {
         return this.sendCorrelatedSessionRequest({
             requestId: options.requestId,
@@ -3606,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;
@@ -3665,29 +4077,14 @@ export class DaemonClient {
             responseType: "file.upload.response",
             options: { skipQueue: true },
         });
-        this.sendBinaryFrame(encodeFileTransferFrame({
-            opcode: FileTransferOpcode.FileBegin,
-            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,
+        this.sendFileTransfer({
             requestId: resolvedRequestId,
-        }));
+            bytes,
+            mime: input.mimeType,
+            fileName: input.fileName,
+            modifiedAt,
+            ...(input.chunkSize === undefined ? {} : { chunkSize: input.chunkSize }),
+        });
         return responsePromise;
     }
     async requestDownloadToken(cwd, path, requestId) {
@@ -3774,7 +4171,7 @@ export class DaemonClient {
      *
      * Pass `workspaceId` whenever the write may be project-scoped: the daemon
      * binds the entry to the repo root that workspace resolves to, and an entry
-     * scoped to "project" with no root is filtered out of every brief — stored,
+     * scoped to "project" with no root is filtered out of every brief - stored,
      * listed, and never sent.
      */
     async updatePersonalityMemory(input, requestId) {
@@ -3961,11 +4358,45 @@ export class DaemonClient {
             responseType: "connectors.list_tools.response",
         });
     }
-    async brainHostStatus(requestId) {
+    /**
+     * Start a connector's OAuth login. Resolves with the URL to open, or with
+     * status "authorized" when the daemon already held a usable token. The login
+     * itself settles later on the `connectors.oauth.status` push, because the user
+     * is in a browser by then.
+     */
+    async connectorsOauthAuthorize(connectorId, scope, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "connectors.oauth.authorize.request",
+                connectorId,
+                ...(scope ? { scope } : {}),
+            },
+            responseType: "connectors.oauth.authorize.response",
+        });
+    }
+    /** Drop a connector's stored authorization. */
+    async connectorsOauthDisconnect(connectorId, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "connectors.oauth.disconnect.request",
+                connectorId,
+            },
+            responseType: "connectors.oauth.disconnect.response",
+        });
+    }
+    /**
+     * The brain's status. Pass `resources` only from a surface that renders the
+     * live CPU/RAM/GPU/slot numbers: it costs an `nvidia-smi` spawn plus a /slots
+     * round trip on the brain, and this call is also the liveness poll.
+     */
+    async brainHostStatus(options, requestId) {
         const payload = await this.sendCorrelatedSessionRequest({
             requestId,
             message: {
                 type: "brain.host.status.request",
+                resources: options?.resources ?? false,
             },
             responseType: "brain.host.status.response",
         });
@@ -4191,6 +4622,123 @@ export class DaemonClient {
         }
         return payload.jobs;
     }
+    // --- Brain Console --------------------------------------------------------
+    // These proxy the brain's own /__host/* management API and work against a
+    // local or a remote brain identically. Gated by features.brainConsole on the
+    // daemon, and by `capabilities` on brain.host.status for the brain itself.
+    // Each throws the brain's own message on failure, because "could not delete
+    // the model" with no reason is not a usable error.
+    /**
+     * The joined model inventory: scan row, GGUF metadata, saved profile,
+     * calibration state, VRAM budget and benchmark score per model, plus disk
+     * usage. One call feeds the whole Models tab.
+     */
+    async brainModelsInventory(requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.models.inventory.request" },
+            responseType: "brain.models.inventory.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return { models: payload.models, disk: payload.disk };
+    }
+    /** One model's saved profile, the field descriptors, and its warnings. */
+    async brainModelProfileGet(modelId, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.model.profile.get.request", modelId },
+            responseType: "brain.model.profile.get.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload;
+    }
+    /**
+     * Write the editable profile fields. The reply carries the recomputed budget,
+     * so an edit costs one round trip rather than a write the UI has to follow
+     * with a read.
+     */
+    async brainModelProfileSet(modelId, patch, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.model.profile.set.request", modelId, patch },
+            responseType: "brain.model.profile.set.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload;
+    }
+    /**
+     * The VRAM budget for a hypothetical profile. `overrides` are string-encoded
+     * field values, so the UI can preview the budget while a control is mid-drag
+     * without persisting a value the user is scrubbing past.
+     */
+    async brainModelBudget(modelId, overrides, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.model.budget.get.request", modelId, overrides: overrides ?? {} },
+            responseType: "brain.model.budget.get.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload;
+    }
+    /**
+     * Load a model into the running brain. This is not `brainHostStart`, which
+     * restarts the daemon's child process and has no remote equivalent.
+     */
+    async brainModelLoad(modelId, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.model.load.request", modelId },
+            responseType: "brain.model.load.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload;
+    }
+    /** Unload the resident model, leaving the brain up and serving nothing. */
+    async brainModelUnload(requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.model.unload.request" },
+            responseType: "brain.model.unload.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload.status;
+    }
+    /** Delete a model's files. The brain refuses while that model is loaded. */
+    async brainModelDelete(modelId, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.model.delete.request", modelId },
+            responseType: "brain.model.delete.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload;
+    }
+    /** Tail the brain's llama-server log. */
+    async brainLogsTail(limit, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "brain.logs.tail.request", limit: limit ?? null },
+            responseType: "brain.logs.tail.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload;
+    }
     async getSpeechSettingsOptions(requestId) {
         return this.sendNamespacedCorrelatedSessionRequest({
             requestId,
@@ -4336,7 +4884,7 @@ export class DaemonClient {
             },
         });
     }
-    /** Daemon-wide "fun stats" — see docs/data-model.md ActivityStatsStore. */
+    /** Daemon-wide "fun stats" - see docs/data-model.md ActivityStatsStore. */
     async getActivityStats(options) {
         return this.sendNamespacedCorrelatedSessionRequest({
             requestId: options?.requestId,
@@ -4354,7 +4902,7 @@ export class DaemonClient {
             },
         });
     }
-    /** Itemized usage ledger — the scrollable rows behind the stats tiles (usage-ledger). */
+    /** Itemized usage ledger - the scrollable rows behind the stats tiles (usage-ledger). */
     async getUsageLog(options) {
         return this.sendNamespacedCorrelatedSessionRequest({
             requestId: options?.requestId,
@@ -5078,7 +5626,7 @@ export class DaemonClient {
     /**
      * Session totals for inbound daemon traffic, including the main-thread time
      * spent handling it. Null when runtime metrics are disabled for this client.
-     * Read by the app's resource monitor — the wire is a first-class suspect when
+     * Read by the app's resource monitor - the wire is a first-class suspect when
      * the UI thread degrades, so it has to be measurable rather than inferred.
      */
     getTrafficTotals() {
@@ -5109,6 +5657,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 } : {}),
@@ -5198,13 +5750,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;
@@ -5485,6 +6042,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) {
@@ -5549,7 +6118,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;
@@ -5582,6 +6151,7 @@ export class DaemonClient {
                 resolve: wrappedResolve,
                 reject: wrappedReject,
                 timeoutHandle,
+                requestId: options?.requestId,
             };
             this.waiters.add(waiter);
         });
@@ -5608,6 +6178,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;