@otto-code/client 0.6.6 → 0.7.0

package/dist/daemon-client.js

@@ -5,7 +5,7 @@ import { isRelayClientWebSocketUrl } from "@otto-code/protocol/daemon-endpoints"
 import { terminalSubscriptionKey } from "@otto-code/protocol/terminal-subscription-key";
 import { asUint8Array, decodeFileTransferFrame, encodeFileTransferFrame, decodeTerminalStreamFrame, FileTransferOpcode, TerminalStreamOpcode, } from "@otto-code/protocol/binary-frames/index";
 import { createRelayE2eeTransportFactory, createWebSocketTransportFactory, decodeMessageData, defaultWebSocketFactory, describeTransportClose, describeTransportError, } from "./daemon-client-transport.js";
-import { DaemonClientRuntimeMetrics } from "./daemon-client-runtime-metrics.js";
+import { DaemonClientRuntimeMetrics, } from "./daemon-client-runtime-metrics.js";
 import { normalizeListProviderModelsPayload, normalizeProviderSnapshotUpdateMessage, normalizeProvidersSnapshotPayload, } from "./compat/normalize-provider-models.js";
 import { TerminalStreamRouter } from "./terminal-stream-router.js";
 const consoleLogger = {
@@ -193,6 +193,9 @@ export class DaemonClient {
         this.checkoutDiffSubscriptions = new Map();
         this.terminalDirectorySubscriptions = 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.
+        this.scaffoldProgressListeners = new Map();
         this.pendingBinaryFileReads = new Map();
         this.activeBinaryFileTransfers = new Map();
         this.completedBinaryFileReads = new Map();
@@ -230,15 +233,23 @@ 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
+        // 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
+        // unconditionally is what lets the app read cumulative traffic (see
+        // getTrafficTotals) without every embedder having to opt in; before this
+        // split, nothing in the app package passed the interval, so client-side wire
+        // accounting existed but never ran.
+        const runtimeMetricsWindowMs = typeof config.runtimeMetricsWindowMs === "number" && config.runtimeMetricsWindowMs > 0
+            ? Math.max(config.runtimeMetricsWindowMs, runtimeMetricsIntervalMs)
+            : undefined;
+        this.runtimeMetrics = new DaemonClientRuntimeMetrics(this.logger, {
+            connectionPath: this.logConnectionPath,
+            serverId: this.logServerId,
+            getConnectionStatus: () => this.connectionState.status,
+        }, runtimeMetricsWindowMs ? { windowMs: runtimeMetricsWindowMs } : undefined);
         if (runtimeMetricsIntervalMs > 0) {
-            const runtimeMetricsWindowMs = typeof config.runtimeMetricsWindowMs === "number" && config.runtimeMetricsWindowMs > 0
-                ? Math.max(config.runtimeMetricsWindowMs, runtimeMetricsIntervalMs)
-                : undefined;
-            this.runtimeMetrics = new DaemonClientRuntimeMetrics(this.logger, {
-                connectionPath: this.logConnectionPath,
-                serverId: this.logServerId,
-                getConnectionStatus: () => this.connectionState.status,
-            }, runtimeMetricsWindowMs ? { windowMs: runtimeMetricsWindowMs } : undefined);
             this.runtimeMetricsInterval = setInterval(() => {
                 this.runtimeMetrics?.flush();
             }, runtimeMetricsIntervalMs);
@@ -445,9 +456,11 @@ export class DaemonClient {
         if (this.runtimeMetricsInterval) {
             clearInterval(this.runtimeMetricsInterval);
             this.runtimeMetricsInterval = null;
+            // Only the interval-logging clients emit the closing window; a
+            // counters-only client has nothing to log.
             this.runtimeMetrics?.flush({ final: true });
-            this.runtimeMetrics = null;
         }
+        this.runtimeMetrics = null;
         this.updateConnectionState({ status: "disposed" }, { event: "DISPOSE", reason: "Client closed", reasonCode: "disposed" });
     }
     ensureConnected() {
@@ -1022,6 +1035,54 @@ export class DaemonClient {
             responseType: "project.add.response",
         });
     }
+    // Creates a project directory from scratch and registers it. Requires
+    // server_info features.projectScaffold. `onProgress` is optional: the
+    // resolved payload carries the authoritative step list either way.
+    async scaffoldProject(options, requestId) {
+        // Resolved here rather than inside sendCorrelatedSessionRequest so the
+        // progress listener is registered under the same id before the send.
+        const resolvedRequestId = this.createRequestId(requestId);
+        if (options.onProgress) {
+            this.scaffoldProgressListeners.set(resolvedRequestId, options.onProgress);
+        }
+        try {
+            return await this.sendCorrelatedSessionRequest({
+                requestId: resolvedRequestId,
+                message: {
+                    type: "project.scaffold.request",
+                    parentDirectory: options.parentDirectory,
+                    folderName: options.folderName,
+                    git: options.git,
+                },
+                responseType: "project.scaffold.response",
+            });
+        }
+        finally {
+            this.scaffoldProgressListeners.delete(resolvedRequestId);
+        }
+    }
+    async listHostingRepositories(options, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "hosting.list_repositories.request",
+                provider: options.provider,
+                query: options.query,
+                limit: options.limit,
+            },
+            responseType: "hosting.list_repositories.response",
+        });
+    }
+    async listHostingOwners(options, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "hosting.list_owners.request",
+                provider: options.provider,
+            },
+            responseType: "hosting.list_owners.response",
+        });
+    }
     async startWorkspaceScript(workspaceId, scriptName, requestId) {
         return this.sendCorrelatedSessionRequest({
             requestId,
@@ -1033,16 +1094,69 @@ export class DaemonClient {
             responseType: "start_workspace_script_response",
         });
     }
-    async archiveWorkspace(workspaceId, requestId) {
+    async archiveWorkspace(workspaceId, options) {
         return this.sendCorrelatedSessionRequest({
-            requestId,
+            requestId: options?.requestId,
             message: {
                 type: "archive_workspace_request",
                 workspaceId,
+                ...(options?.branchDisposition ? { branchDisposition: options.branchDisposition } : {}),
             },
             responseType: "archive_workspace_response",
         });
     }
+    // Read-only pre-archive inspection of a worktree's leftover branch (merge
+    // state, deletability). Gated by server_info.features.worktreeArchiveBranchCleanup.
+    async workspaceArchivePreflight(workspaceId, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "workspace.archive.preflight.request",
+                workspaceId,
+            },
+            responseType: "workspace.archive.preflight.response",
+        });
+    }
+    // Repoint a worktree-backed workspace's base branch (what Changes diffs against,
+    // and what merge-into-base / PR creation target). Pass null to reset to the
+    // repository default. Gated by server_info.features.worktreeDiffBase.
+    async setWorktreeBaseRef(workspaceId, baseRef, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "worktree.baseRef.set.request",
+                workspaceId,
+                baseRef,
+            },
+            responseType: "worktree.baseRef.set.response",
+        });
+    }
+    // List re-attachable Otto worktrees for a project (or the repo containing cwd):
+    // archived worktree workspaces with a kept branch, plus orphaned on-disk
+    // worktrees. Gated by server_info.features.worktreeReattach.
+    async listReattachableWorktrees(scope, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "worktree.reattach.list.request",
+                ...(scope.projectId ? { projectId: scope.projectId } : {}),
+                ...(scope.cwd ? { cwd: scope.cwd } : {}),
+            },
+            responseType: "worktree.reattach.list.response",
+        });
+    }
+    // Re-attach a "left" worktree as a live workspace: revive an archived workspace
+    // record in place, or bind a fresh workspace to an orphaned on-disk worktree.
+    async reattachWorktree(target, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "worktree.reattach.request",
+                target,
+            },
+            responseType: "worktree.reattach.response",
+        });
+    }
     async fetchWorkspaceSetupStatus(workspaceId, requestId) {
         return this.sendCorrelatedSessionRequest({
             requestId,
@@ -1207,6 +1321,26 @@ export class DaemonClient {
             },
         });
     }
+    /**
+     * Bulk-delete archived chat records on this host. Server-side by necessity:
+     * the client's history list is cursor-paginated across hosts and never holds
+     * 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
+     * by `server_info.features.historyDelete`; there is no fallback path, so check
+     * the flag before offering the action.
+     */
+    async clearArchivedAgents(options) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "history.agents.clear_archived.request",
+                dryRun: options.dryRun,
+                olderThanDays: options.olderThanDays ?? 0,
+            },
+        });
+    }
     async archiveAgent(agentId) {
         const requestId = this.createRequestId();
         const message = SessionInboundMessageSchema.parse({
@@ -1358,6 +1492,114 @@ export class DaemonClient {
         });
         return payload.runIds;
     }
+    /**
+     * Orchestration: delete one finished (or draft) run. Throws with the
+     * daemon's reason when it refuses — an active run has to be canceled first.
+     */
+    async deleteRun(runId) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "runs.delete.request", runId },
+        });
+        if (!payload.runId) {
+            throw new Error(payload.error ?? "Failed to delete the orchestration");
+        }
+        return payload.runId;
+    }
+    /** Orchestration: list the host's reusable graph templates. */
+    async listOrchestrationGraphs() {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "runs.graphs.list.request" },
+        });
+        return payload.graphs;
+    }
+    /** Orchestration: upsert a graph template. Returns the persisted graph. */
+    async saveOrchestrationGraph(graph) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "runs.graphs.save.request", graph },
+        });
+        if (payload.error !== undefined || payload.graph === undefined) {
+            throw new Error(payload.error ?? "saveOrchestrationGraph rejected");
+        }
+        return payload.graph;
+    }
+    /** Orchestration: delete a graph template (built-in starters refuse). */
+    async deleteOrchestrationGraph(graphId) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "runs.graphs.delete.request", graphId },
+        });
+        if (payload.error !== undefined) {
+            throw new Error(payload.error);
+        }
+        return payload.deleted;
+    }
+    /** Orchestration: list the host's reusable prompt templates and snippets. */
+    async listPromptTemplates() {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "runs.templates.list.request" },
+        });
+        return payload.templates;
+    }
+    /** Orchestration: upsert a prompt template. Returns the persisted template. */
+    async savePromptTemplate(template) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "runs.templates.save.request", template },
+        });
+        if (payload.error !== undefined || payload.template === undefined) {
+            throw new Error(payload.error ?? "savePromptTemplate rejected");
+        }
+        return payload.template;
+    }
+    /** Orchestration: delete a prompt template (built-in starters refuse). */
+    async deletePromptTemplate(templateId) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "runs.templates.delete.request", templateId },
+        });
+        if (payload.error !== undefined) {
+            throw new Error(payload.error);
+        }
+        return payload.deleted;
+    }
+    /**
+     * Orchestration: start (or draft) a user-initiated orchestration. Returns the
+     * run id (graph flavor) and the orchestrator chat's agent id to navigate to.
+     */
+    async startOrchestration(input) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            message: {
+                type: "runs.start.request",
+                flavor: input.flavor,
+                cwd: input.cwd,
+                ...(input.workspaceId !== undefined ? { workspaceId: input.workspaceId } : {}),
+                ...(input.title !== undefined ? { title: input.title } : {}),
+                ...(input.description !== undefined ? { description: input.description } : {}),
+                ...(input.orchestratorPersonalityId !== undefined
+                    ? { orchestratorPersonalityId: input.orchestratorPersonalityId }
+                    : {}),
+                ...(input.orchestratorProvider !== undefined
+                    ? { orchestratorProvider: input.orchestratorProvider }
+                    : {}),
+                ...(input.orchestratorModel !== undefined
+                    ? { orchestratorModel: input.orchestratorModel }
+                    : {}),
+                ...(input.orchestratorThinkingOptionId !== undefined
+                    ? { orchestratorThinkingOptionId: input.orchestratorThinkingOptionId }
+                    : {}),
+                ...(input.prompt !== undefined ? { prompt: input.prompt } : {}),
+                ...(input.graphId !== undefined ? { graphId: input.graphId } : {}),
+                ...(input.graphInputs !== undefined ? { graphInputs: input.graphInputs } : {}),
+                ...(input.draft !== undefined ? { draft: input.draft } : {}),
+                ...(input.runId !== undefined ? { runId: input.runId } : {}),
+            },
+        });
+        if (payload.error !== undefined) {
+            throw new Error(payload.error);
+        }
+        return {
+            ...(payload.runId !== undefined ? { runId: payload.runId } : {}),
+            ...(payload.agentId !== undefined ? { agentId: payload.agentId } : {}),
+            ...(payload.workspaceId !== undefined ? { workspaceId: payload.workspaceId } : {}),
+        };
+    }
     async updateAgent(agentId, updates) {
         const requestId = this.createRequestId();
         const message = SessionInboundMessageSchema.parse({
@@ -1616,6 +1858,7 @@ export class DaemonClient {
             ...(messageId ? { messageId } : {}),
             ...(options?.images ? { images: options.images } : {}),
             ...(options?.attachments ? { attachments: options.attachments } : {}),
+            ...(options?.delivery ? { delivery: options.delivery } : {}),
         });
         const payload = await this.sendRequest({
             requestId,
@@ -1634,10 +1877,107 @@ export class DaemonClient {
         if (!payload.accepted) {
             throw new Error(payload.error ?? "sendAgentMessage rejected");
         }
+        return {
+            queued: payload.queued ?? false,
+            queuedMessageId: payload.queuedMessageId ?? null,
+        };
     }
     async sendMessage(agentId, text, options) {
         await this.sendAgentMessage(agentId, text, options);
     }
+    /**
+     * Pull one message back out of an agent's queue. Returns its text so the
+     * caller can put it back in the composer, or null when the turn already
+     * drained it. Requires `server_info.features.steerQueue`.
+     */
+    async removeQueuedAgentMessage(agentId, messageId) {
+        const requestId = this.createRequestId();
+        const message = SessionInboundMessageSchema.parse({
+            type: "agent.queue.remove.request",
+            requestId,
+            agentId,
+            messageId,
+        });
+        const payload = await this.sendRequest({
+            requestId,
+            message,
+            options: { skipQueue: true },
+            select: (msg) => {
+                if (msg.type !== "agent.queue.remove.response") {
+                    return null;
+                }
+                if (msg.payload.requestId !== requestId) {
+                    return null;
+                }
+                return msg.payload;
+            },
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload.removed;
+    }
+    /**
+     * Move one queued message to a new position. Resolves false when the entry
+     * was already drained or was already there — the authoritative order arrives
+     * on the agent snapshot either way. Requires
+     * `server_info.features.steerQueueReorder`.
+     */
+    async reorderQueuedAgentMessage(agentId, messageId, toIndex) {
+        const requestId = this.createRequestId();
+        const message = SessionInboundMessageSchema.parse({
+            type: "agent.queue.reorder.request",
+            requestId,
+            agentId,
+            messageId,
+            toIndex,
+        });
+        const payload = await this.sendRequest({
+            requestId,
+            message,
+            options: { skipQueue: true },
+            select: (msg) => {
+                if (msg.type !== "agent.queue.reorder.response") {
+                    return null;
+                }
+                if (msg.payload.requestId !== requestId) {
+                    return null;
+                }
+                return msg.payload;
+            },
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload.moved;
+    }
+    /** Drop every message queued behind an agent's current turn. */
+    async clearAgentQueue(agentId) {
+        const requestId = this.createRequestId();
+        const message = SessionInboundMessageSchema.parse({
+            type: "agent.queue.clear.request",
+            requestId,
+            agentId,
+        });
+        const payload = await this.sendRequest({
+            requestId,
+            message,
+            options: { skipQueue: true },
+            select: (msg) => {
+                if (msg.type !== "agent.queue.clear.response") {
+                    return null;
+                }
+                if (msg.payload.requestId !== requestId) {
+                    return null;
+                }
+                return msg.payload;
+            },
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload.clearedCount;
+    }
     async rewindAgent(agentId, messageId, mode) {
         const requestId = this.createRequestId();
         const message = SessionInboundMessageSchema.parse({
@@ -2793,6 +3133,62 @@ export class DaemonClient {
         });
         return payload.result;
     }
+    /** 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,
+            message: {
+                type: "file.refine.request",
+                cwd: options.cwd,
+                documents: options.documents,
+                references: options.references,
+                instruction: options.instruction,
+            },
+            responseType: "file.refine.response",
+        });
+        return payload.result;
+    }
     /**
      * Project-wide search. Per-file results stream through onFileResult (the
      * daemon emits them in order, before the summary response resolves); the
@@ -2848,6 +3244,265 @@ export class DaemonClient {
         }
         return payload.locations;
     }
+    /**
+     * Language-server-backed go-to-definition. Unlike `findCodeSymbols` this resolves the
+     * reference *at a position*, so multiple results mean real overloads or
+     * implementations rather than "two files happen to use this name".
+     *
+     * Line and column are 1-based. Returns the whole payload, not just the locations,
+     * because `indexing` and `unavailable` are answers the caller must show differently
+     * from an empty result.
+     */
+    async findCodeDefinition(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "code.definition.request",
+                cwd: input.cwd,
+                path: input.path,
+                line: input.line,
+                column: input.column,
+            },
+            responseType: "code.definition.response",
+        });
+        return { status: payload.status, locations: payload.locations, error: payload.error };
+    }
+    /**
+     * 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.
+     */
+    async syncCodeDocument(cwd, path, text, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "code.document.sync.request", cwd, path, text },
+            responseType: "code.document.sync.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+    }
+    /** Release the daemon-side mirror when a file tab closes. */
+    async closeCodeDocument(cwd, path, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "code.document.close.request", cwd, path },
+            responseType: "code.document.close.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+    }
+    /**
+     * The language server's own explanation of the symbol at a position. Returns the
+     * whole payload: `indexing` and `unavailable` read differently to a user than "the
+     * server had nothing to say", which is `ok` with a null `markdown`.
+     */
+    async getCodeHover(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "code.hover.request",
+                cwd: input.cwd,
+                path: input.path,
+                line: input.line,
+                column: input.column,
+            },
+            responseType: "code.hover.response",
+        });
+        return {
+            status: payload.status,
+            markdown: payload.markdown,
+            range: payload.range,
+            serverId: payload.serverId,
+            error: payload.error,
+        };
+    }
+    /** Every reference to the symbol at a position, for the references results tab. */
+    async findCodeReferences(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "code.references.request",
+                cwd: input.cwd,
+                path: input.path,
+                line: input.line,
+                column: input.column,
+            },
+            responseType: "code.references.response",
+        });
+        return { status: payload.status, locations: payload.locations, error: payload.error };
+    }
+    /**
+     * 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) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "code.rename.preview.request",
+                cwd: input.cwd,
+                path: input.path,
+                line: input.line,
+                column: input.column,
+                newName: input.newName,
+            },
+            responseType: "code.rename.preview.response",
+        });
+        return {
+            status: payload.status,
+            files: payload.files,
+            fileCount: payload.fileCount,
+            editCount: payload.editCount,
+            planId: payload.planId,
+            error: payload.error,
+        };
+    }
+    /**
+     * Execute a rename the user audited. Sends the  and NOT the edits: the daemon
+     * recomputes the plan and refuses unless the identity still matches, which is what keeps
+     * this from being an arbitrary-write RPC and what makes "what you approved is what
+     * happens" enforceable rather than merely intended.
+     */
+    async applyCodeRename(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "code.rename.apply.request",
+                cwd: input.cwd,
+                path: input.path,
+                line: input.line,
+                column: input.column,
+                newName: input.newName,
+                planId: input.planId,
+            },
+            responseType: "code.rename.apply.response",
+        });
+        return {
+            status: payload.status,
+            runId: payload.runId,
+            files: payload.files,
+            appliedFiles: payload.appliedFiles,
+            appliedEdits: payload.appliedEdits,
+            skippedEdits: payload.skippedEdits,
+            complete: payload.complete,
+            error: payload.error,
+        };
+    }
+    /**
+     * Take a rename run back. Sends only the run id: the daemon holds the before-images, and
+     * restores a file only if it still holds exactly what the run wrote.
+     */
+    async undoCodeRename(cwd, runId, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "code.rename.undo.request", cwd, runId },
+            responseType: "code.rename.undo.response",
+        });
+        return {
+            status: payload.status,
+            files: payload.files,
+            restoredFiles: payload.restoredFiles,
+            complete: payload.complete,
+            error: payload.error,
+        };
+    }
+    /**
+     * Live language-server state for the Daemon → Code screen: what this host can
+     * supply, and what is running now. `cwd` scopes availability, since a server can
+     * be present in one workspace's `node_modules` and absent in another's.
+     */
+    async listLspServers(cwd, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "lsp.servers.list.request", cwd },
+            responseType: "lsp.servers.list.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return { languages: payload.languages, running: payload.running };
+    }
+    /** Stop one running language server. */
+    async stopLspServer(rootPath, serverId, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "lsp.server.stop.request", rootPath, serverId },
+            responseType: "lsp.server.stop.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+    }
+    /**
+     * Solutions in a workspace, which is what decides whether the Files tab shows a view switcher
+     * at all.
+     *
+     * 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.
+     */
+    async listSolutions(cwd, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "code.solution.list.request", cwd },
+            responseType: "code.solution.list.response",
+        });
+        return payload.solutions;
+    }
+    /** One solution's organisation: folders, the projects inside them, configurations. */
+    async getSolutionTree(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "code.solution.get_tree.request",
+                cwd: input.cwd,
+                solutionPath: input.solutionPath,
+            },
+            responseType: "code.solution.get_tree.response",
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return {
+            solutionPath: payload.solutionPath,
+            name: payload.name,
+            format: payload.format,
+            folders: payload.folders,
+            projects: payload.projects,
+            buildTypes: payload.buildTypes,
+            platforms: payload.platforms,
+        };
+    }
+    /**
+     * One project's evaluated file membership, fetched on expand.
+     *
+     * A `failed` status is a normal answer, not an exception: the daemon carries MSBuild's own
+     * message for a project it refused, and one bad project must not blank the tree.
+     */
+    async loadSolutionProject(input, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "code.solution.load_project.request",
+                cwd: input.cwd,
+                solutionPath: input.solutionPath,
+                projectPath: input.projectPath,
+            },
+            responseType: "code.solution.load_project.response",
+        });
+        return {
+            projectPath: payload.projectPath,
+            status: payload.status,
+            nodes: payload.nodes,
+            projectReferences: payload.projectReferences,
+            packageReferences: payload.packageReferences,
+            targetFrameworks: payload.targetFrameworks,
+            outputType: payload.outputType,
+            isSdkStyle: payload.isSdkStyle,
+            error: payload.error,
+        };
+    }
     /** Definition symbols for a single file (document outline). */
     async getCodeOutline(cwd, path, requestId) {
         const payload = await this.sendCorrelatedSessionRequest({
@@ -3000,10 +3655,76 @@ export class DaemonClient {
                 workspaceId: input.workspaceId,
                 ...(input.provider ? { provider: input.provider } : {}),
                 ...(typeof input.windowTokens === "number" ? { windowTokens: input.windowTokens } : {}),
+                ...(input.personalityId ? { personalityId: input.personalityId } : {}),
             },
             responseType: "context.report.get.response",
         });
     }
+    // ============================================================================
+    // Personality memory
+    // ============================================================================
+    /**
+     * A personality's accrued lessons plus the EXACT brief the daemon would inject
+     * for `projectRoot`. The brief is returned rather than rebuilt client-side
+     * because memory is only trustworthy if what you are shown is what is sent.
+     */
+    async listPersonalityMemory(input, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "personality.memory.list.request",
+                personalityId: input.personalityId,
+                ...(input.workspaceId ? { workspaceId: input.workspaceId } : {}),
+                ...(input.projectRoot ? { projectRoot: input.projectRoot } : {}),
+            },
+        });
+    }
+    /**
+     * Add (no `entryId`), edit, or forget (`drop`) one lesson.
+     *
+     * 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,
+     * listed, and never sent.
+     */
+    async updatePersonalityMemory(input, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "personality.memory.update.request",
+                personalityId: input.personalityId,
+                ...(input.entryId ? { entryId: input.entryId } : {}),
+                ...(input.text !== undefined ? { text: input.text } : {}),
+                ...(input.scope ? { scope: input.scope } : {}),
+                ...(input.workspaceId ? { workspaceId: input.workspaceId } : {}),
+                ...(input.projectRoot ? { projectRoot: input.projectRoot } : {}),
+                ...(input.drop ? { drop: true } : {}),
+            },
+        });
+    }
+    /**
+     * Resolve a deleted personality's lessons: move them to another personality or
+     * discard them. Called BEFORE the roster write, so a failure leaves both the
+     * personality and its memory intact.
+     */
+    async transferPersonalityMemory(input, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "personality.memory.transfer.request",
+                fromPersonalityId: input.fromPersonalityId,
+                ...(input.toPersonalityId ? { toPersonalityId: input.toPersonalityId } : {}),
+                mode: input.mode,
+            },
+        });
+    }
+    /** Per-personality lesson counts, for the accrual indicator and the selector. */
+    async getPersonalityMemoryStats(requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: { type: "personality.memory.stats.request" },
+        });
+    }
     /** Rewrites one reference between "always loaded" and "link only". */
     async requestContextEdgeConvert(input, requestId) {
         return this.sendCorrelatedSessionRequest({
@@ -3019,6 +3740,17 @@ export class DaemonClient {
             responseType: "context.edge.convert.response",
         });
     }
+    /** Deletes every mechanically-fixable finding's range in one pass. */
+    async requestContextFindingsFix(input, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "context.findings.fix.request",
+                workspaceId: input.workspaceId,
+                findings: input.findings,
+            },
+        });
+    }
     // ============================================================================
     // Provider Models / Commands
     // ============================================================================
@@ -3147,6 +3879,27 @@ export class DaemonClient {
             },
         });
     }
+    // Stream a full message aloud on demand (per-message playback button). Audio
+    // arrives as `audio_output` chunks the session already plays; this promise
+    // resolves when playback finishes, is canceled, or errors. `voice` is the
+    // speaking agent's personality voice (resolved on the client).
+    async speakMessage(params, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "speech.tts.speak.request",
+                text: params.text,
+                ...(params.voice ? { voice: params.voice } : {}),
+            },
+        });
+    }
+    // Stop the in-flight message playback started by speakMessage.
+    async cancelSpeakMessage(requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: { type: "speech.tts.speak.cancel.request" },
+        });
+    }
     // Author short spoken cue lines (join / thinking / done) for a persona,
     // described inline (name + prompt) so it works for an unsaved editor draft.
     // Routed through the Writer chain; the caller stores the result on the
@@ -3970,6 +4723,18 @@ export class DaemonClient {
     getLastServerInfoMessage() {
         return this.lastServerInfoMessage;
     }
+    /**
+     * 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
+     * the UI thread degrades, so it has to be measurable rather than inferred.
+     */
+    getTrafficTotals() {
+        return this.runtimeMetrics?.getTrafficTotals() ?? null;
+    }
+    getTrafficHotspots(limit) {
+        return this.runtimeMetrics?.getTrafficHotspots(limit) ?? [];
+    }
     resolveTransportUrlForAttempt() {
         return this.config.url;
     }
@@ -4321,6 +5086,12 @@ export class DaemonClient {
         if (consumerMessage.type === "terminal_stream_exit") {
             this.terminalStreams.removeTerminal(consumerMessage.payload.terminalId);
         }
+        // Scaffold progress is advisory and scoped to one in-flight request, so it
+        // is delivered to that request's own listener rather than the global
+        // DaemonEvent stream every consumer would then have to ignore.
+        if (consumerMessage.type === "project.scaffold.progress") {
+            this.scaffoldProgressListeners.get(consumerMessage.payload.requestId)?.(consumerMessage.payload);
+        }
         if (this.rawMessageListeners.size > 0) {
             for (const handler of this.rawMessageListeners) {
                 try {