@otto-code/client 0.8.19 → 0.9.0

package/dist/daemon-client.js

@@ -253,6 +253,35 @@ function unwrapBrainJob(payload) {
 // 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;
+function buildWorkflowStartRequest(input) {
+    return {
+        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.startConfirmationToken !== undefined
+            ? { startConfirmationToken: input.startConfirmationToken }
+            : {}),
+        ...(input.draft !== undefined ? { draft: input.draft } : {}),
+        ...(input.runId !== undefined ? { runId: input.runId } : {}),
+    };
+}
 export class DaemonClient {
     constructor(config) {
         this.config = config;
@@ -1061,6 +1090,7 @@ export class DaemonClient {
             ...(options?.sort ? { sort: options.sort } : {}),
             ...(options?.page ? { page: options.page } : {}),
             ...(options?.subscribe ? { subscribe: options.subscribe } : {}),
+            ...(options?.sync ? { sync: options.sync } : {}),
         });
         return this.sendRequest({
             requestId: resolvedRequestId,
@@ -1143,6 +1173,7 @@ export class DaemonClient {
             ...(options?.sort ? { sort: options.sort } : {}),
             ...(options?.page ? { page: options.page } : {}),
             ...(options?.subscribe ? { subscribe: options.subscribe } : {}),
+            ...(options?.sync ? { sync: options.sync } : {}),
         });
         return this.sendRequest({
             requestId: resolvedRequestId,
@@ -1159,6 +1190,74 @@ export class DaemonClient {
             },
         });
     }
+    listWorkspaceLabels(options) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "workspace.label.list.request",
+                subscribe: { subscriptionId: options.subscriptionId },
+                ...(options.sync ? { sync: options.sync } : {}),
+            },
+        });
+    }
+    setWorkspaceLabel(options) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "workspace.label.assignment.set.request",
+                workspaceId: options.workspaceId,
+                label: options.label,
+                assigned: options.assigned,
+            },
+        });
+    }
+    updateWorkspaceLabel(options) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "workspace.label.update.request",
+                name: options.name,
+                ...(options.newName === undefined ? {} : { newName: options.newName }),
+                ...(options.color === undefined ? {} : { color: options.color }),
+            },
+        });
+    }
+    deleteWorkspaceLabel(options) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: { type: "workspace.label.delete.request", name: options.name },
+        });
+    }
+    inspectWorkspaceLabelDelete(options) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "workspace.label.delete.inspect.request",
+                name: options.name,
+            },
+        });
+    }
+    async listProjects(options) {
+        const requestId = typeof options === "string" ? options : options?.requestId;
+        const resolvedRequestId = this.createRequestId(requestId);
+        const message = SessionInboundMessageSchema.parse({
+            type: "project.list.request",
+            requestId: resolvedRequestId,
+            ...(typeof options === "object" && options.sync ? { sync: options.sync } : {}),
+        });
+        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;
+            },
+        });
+    }
     async openProject(cwd, requestId) {
         return this.sendCorrelatedSessionRequest({
             requestId,
@@ -1419,6 +1518,9 @@ export class DaemonClient {
             ...(options.personality ? { personality: options.personality } : {}),
             ...(options.env ? { env: options.env } : {}),
             ...(options.workspaceId !== undefined ? { workspaceId: options.workspaceId } : {}),
+            ...(options.architecturalViewDraft
+                ? { architecturalViewDraft: options.architecturalViewDraft }
+                : {}),
             ...(options.callerAgentId !== undefined ? { callerAgentId: options.callerAgentId } : {}),
             ...(options.initialPrompt ? { initialPrompt: options.initialPrompt } : {}),
             ...(options.clientMessageId ? { clientMessageId: options.clientMessageId } : {}),
@@ -1703,6 +1805,26 @@ export class DaemonClient {
         });
         return payload.graphs;
     }
+    /** List saved Workflow Graphs for one project, never the legacy host library. */
+    async listProjectWorkflowGraphs(cwd) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "workflows.graphs.list.request", cwd },
+        });
+        if (payload.error !== undefined) {
+            throw new Error(payload.error);
+        }
+        return payload.graphs;
+    }
+    /** Persist a Graph in the selected project Workflow store. */
+    async saveProjectWorkflowGraph(cwd, graph) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "workflows.graph.save.request", cwd, graph },
+        });
+        if (payload.error !== undefined || payload.graph === undefined) {
+            throw new Error(payload.error ?? "Project Workflow Graph save rejected");
+        }
+        return payload.graph;
+    }
     /** Orchestration: upsert a graph template. Returns the persisted graph. */
     async saveOrchestrationGraph(graph) {
         const payload = await this.sendNamespacedCorrelatedSessionRequest({
@@ -1723,6 +1845,22 @@ export class DaemonClient {
         }
         return payload.deleted;
     }
+    async exportWorkflowGraph(graphId) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "workflows.graph.export.request", graphId },
+        });
+        if (!payload.export)
+            throw new Error(payload.error ?? "Graph export rejected");
+        return payload.export;
+    }
+    async importWorkflowGraph(input) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "workflows.graph.import.request", ...input },
+        });
+        if (!payload.result)
+            throw new Error(payload.error ?? "Graph import rejected");
+        return payload.result;
+    }
     /** Orchestration: list the host's reusable prompt templates and snippets. */
     async listPromptTemplates() {
         const payload = await this.sendNamespacedCorrelatedSessionRequest({
@@ -1730,6 +1868,32 @@ export class DaemonClient {
         });
         return payload.templates;
     }
+    async listProjectWorkflowTemplates(cwd) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "workflows.templates.list.request", cwd },
+        });
+        if (payload.error !== undefined)
+            throw new Error(payload.error);
+        return payload.templates;
+    }
+    async saveProjectWorkflowTemplate(cwd, template) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "workflows.template.save.request", cwd, template },
+        });
+        if (payload.error !== undefined || payload.template === undefined) {
+            throw new Error(payload.error ?? "Project Workflow template save rejected");
+        }
+        return payload.template;
+    }
+    async transferProjectWorkflowRecord(input) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "workflows.storage.transfer.request", ...input },
+        });
+        if (payload.error !== undefined || payload.receipt === undefined) {
+            throw new Error(payload.error ?? "Project Workflow transfer rejected");
+        }
+        return payload.receipt;
+    }
     /** Orchestration: upsert a prompt template. Returns the persisted template. */
     async savePromptTemplate(template) {
         const payload = await this.sendNamespacedCorrelatedSessionRequest({
@@ -1751,37 +1915,20 @@ export class DaemonClient {
         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.
+     * Workflow: start (or draft) a user-initiated Workflow. Returns the workflow
+     * 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 } : {}),
-            },
-        });
+    async startWorkflow(input) {
+        const request = buildWorkflowStartRequest(input);
+        // COMPAT(runsStartRpc): retain the established request against older
+        // daemons until the legacy pair retires after 2027-02-28.
+        const payload = this.lastServerInfoMessage?.features?.workflowStartRpc === true
+            ? await this.sendNamespacedCorrelatedSessionRequest({
+                message: { type: "workflows.start.request", ...request },
+            })
+            : await this.sendNamespacedCorrelatedSessionRequest({
+                message: { type: "runs.start.request", ...request },
+            });
         if (payload.error !== undefined) {
             throw new Error(payload.error);
         }
@@ -1789,8 +1936,19 @@ export class DaemonClient {
             ...(payload.runId !== undefined ? { runId: payload.runId } : {}),
             ...(payload.agentId !== undefined ? { agentId: payload.agentId } : {}),
             ...(payload.workspaceId !== undefined ? { workspaceId: payload.workspaceId } : {}),
+            ...(payload.confirmation !== undefined ? { confirmation: payload.confirmation } : {}),
+            ...(payload.confirmationToken !== undefined
+                ? { confirmationToken: payload.confirmationToken }
+                : {}),
         };
     }
+    /** Answer a daemon-owned AI Workflow start confirmation. */
+    async respondToWorkflowStartConfirmation(input) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "workflows.start_confirmation.respond.request", ...input },
+        });
+        return payload.accepted;
+    }
     async updateAgent(agentId, updates) {
         const requestId = this.createRequestId();
         const message = SessionInboundMessageSchema.parse({
@@ -2213,25 +2371,6 @@ export class DaemonClient {
         }
         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") {
@@ -2443,6 +2582,7 @@ export class DaemonClient {
             agentId,
             text,
             ...(messageId ? { messageId } : {}),
+            ...(options?.activeTurnBehavior ? { activeTurnBehavior: options.activeTurnBehavior } : {}),
             ...(options?.images ? { images: options.images } : {}),
             ...(options?.attachments ? { attachments: options.attachments } : {}),
             ...(options?.delivery ? { delivery: options.delivery } : {}),
@@ -3709,7 +3849,7 @@ export class DaemonClient {
     // ============================================================================
     // File Explorer
     // ============================================================================
-    async requestFileExplorer(cwd, path, mode, requestId, acceptBinary = false) {
+    async requestFileExplorer(cwd, path, mode, requestId, acceptBinary = false, maxBytes) {
         return this.sendCorrelatedSessionRequest({
             requestId,
             message: {
@@ -3718,6 +3858,7 @@ export class DaemonClient {
                 path,
                 mode,
                 ...(acceptBinary ? { acceptBinary: true } : {}),
+                ...(maxBytes ? { maxBytes } : {}),
             },
             responseType: "file_explorer_response",
         });
@@ -3732,11 +3873,11 @@ export class DaemonClient {
         }
         return payload.directory;
     }
-    async readFile(cwd, path, requestId) {
+    async readFile(cwd, path, requestId, maxBytes) {
         const resolvedRequestId = this.createRequestId(requestId);
-        this.pendingBinaryFileReads.set(resolvedRequestId, { cwd, path });
+        this.pendingBinaryFileReads.set(resolvedRequestId, { cwd, path, maxBytes });
         try {
-            const payload = await this.requestFileExplorer(cwd, path, "file", resolvedRequestId, true);
+            const payload = await this.requestFileExplorer(cwd, path, "file", resolvedRequestId, true, maxBytes);
             if (payload.error) {
                 throw new Error(payload.error);
             }
@@ -4610,6 +4751,37 @@ export class DaemonClient {
             timeout: options?.timeout,
         });
     }
+    async reloadDaemonConfig(requestId) {
+        this.requireDaemonConfigReloadSupport();
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: { type: "daemon.config.reload.request" },
+        });
+    }
+    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",
+        });
+    }
     async getDaemonPairingOffer(options) {
         return this.sendCorrelatedSessionRequest({
             requestId: options?.requestId,
@@ -5549,6 +5721,135 @@ export class DaemonClient {
             response,
         });
     }
+    async getPluginCatalog() {
+        const requestId = this.createRequestId();
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "plugin.catalog.get.request", requestId },
+            responseType: "plugin.catalog.get.response",
+        });
+        return payload.plugins;
+    }
+    async listPlugins() {
+        const requestId = this.createRequestId();
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "plugin.list.request", requestId },
+            responseType: "plugin.list.response",
+        });
+        return payload.plugins;
+    }
+    async getPluginLogs(pluginId) {
+        const requestId = this.createRequestId();
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "plugin.logs.get.request", requestId, pluginId },
+            responseType: "plugin.logs.get.response",
+        });
+        return payload.entries;
+    }
+    async getAgentSkillsStatus() {
+        const requestId = this.createRequestId();
+        return this.sendCorrelatedSessionRequest({
+            message: { type: "agent.skills.get_status.request", requestId },
+            responseType: "agent.skills.get_status.response",
+        });
+    }
+    async reconcileAgentSkills() {
+        const requestId = this.createRequestId();
+        return this.sendCorrelatedSessionRequest({
+            message: { type: "agent.skills.reconcile.request", requestId },
+            responseType: "agent.skills.reconcile.response",
+        });
+    }
+    async uninstallAgentSkills() {
+        const requestId = this.createRequestId();
+        return this.sendCorrelatedSessionRequest({
+            message: { type: "agent.skills.uninstall.request", requestId },
+            responseType: "agent.skills.uninstall.response",
+        });
+    }
+    async saveAgentSkillsSelection(selection, confirmedRemovals) {
+        const requestId = this.createRequestId();
+        return this.sendCorrelatedSessionRequest({
+            message: {
+                type: "agent.skills.save_selection.request",
+                requestId,
+                selection,
+                ...(confirmedRemovals ? { confirmedRemovals: [...confirmedRemovals] } : {}),
+            },
+            responseType: "agent.skills.save_selection.response",
+        });
+    }
+    async importLegacyAgentSkillsSelection(selection) {
+        const requestId = this.createRequestId();
+        return this.sendCorrelatedSessionRequest({
+            message: {
+                type: "agent.skills.import_legacy_selection.request",
+                requestId,
+                selection,
+            },
+            responseType: "agent.skills.import_legacy_selection.response",
+        });
+    }
+    async installDirectoryPlugin(path, id) {
+        const requestId = this.createRequestId();
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "plugin.directory.install.request", requestId, path, ...(id ? { id } : {}) },
+            responseType: "plugin.directory.install.response",
+        });
+        return payload.plugin;
+    }
+    async inspectDirectoryPlugin(path) {
+        const requestId = this.createRequestId();
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "plugin.directory.inspect.request", requestId, path },
+            responseType: "plugin.directory.inspect.response",
+        });
+    }
+    async reloadPlugin(pluginId) {
+        return this.managePlugin("reload", pluginId);
+    }
+    async enablePlugin(pluginId) {
+        return this.managePlugin("enable", pluginId);
+    }
+    async disablePlugin(pluginId) {
+        return this.managePlugin("disable", pluginId);
+    }
+    async removePlugin(pluginId) {
+        const requestId = this.createRequestId();
+        await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "plugin.remove.request", requestId, pluginId },
+            responseType: "plugin.remove.response",
+        });
+    }
+    async managePlugin(action, pluginId) {
+        const requestId = this.createRequestId();
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: `plugin.${action}.request`, requestId, pluginId },
+            responseType: `plugin.${action}.response`,
+        });
+        return payload.plugin;
+    }
+    async invokePluginRpc(pluginId, method, input) {
+        const requestId = this.createRequestId();
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "plugin.rpc.invoke.request",
+                requestId,
+                pluginId,
+                method,
+                input,
+            },
+            responseType: "plugin.rpc.invoke.response",
+        });
+        return payload.output;
+    }
     async respondToPermissionAndWait(agentId, requestId, response, timeout = 15000) {
         const message = SessionInboundMessageSchema.parse({
             type: "agent_permission_response",
@@ -5974,6 +6275,32 @@ export class DaemonClient {
             responseType: "artifact.list.response",
         });
     }
+    async setProjectArtifactStoreLocation(input) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId: input.requestId,
+            message: {
+                type: "project.artifact.store.set.request",
+                projectId: input.projectId,
+                location: input.location,
+            },
+            responseType: "project.artifact.store.set.response",
+        });
+        if (!payload.accepted)
+            throw new Error(payload.error ?? "Artifact storage update rejected");
+    }
+    /** Requires server_info.features.categoryStorageResolver for Workflows. */
+    async setProjectWorkflowStoreLocation(input) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            requestId: input.requestId,
+            message: {
+                type: "project.workflow.store.set.request",
+                projectId: input.projectId,
+                location: input.location,
+            },
+        });
+        if (!payload.accepted)
+            throw new Error(payload.error ?? "Workflow storage update rejected");
+    }
     async artifactCreate(options) {
         return this.sendCorrelatedSessionRequest({
             requestId: options.requestId,
@@ -6062,6 +6389,151 @@ export class DaemonClient {
             responseType: "artifact.get-content.response",
         });
     }
+    async artifactRepair(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "artifact.repair.request",
+                artifactId: options.artifactId,
+            },
+            responseType: "artifact.repair.response",
+        });
+    }
+    async artifactGetData(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "artifact.data.get.request",
+                artifactId: options.artifactId,
+            },
+            responseType: "artifact.data.get.response",
+        });
+    }
+    async artifactUpdateData(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "artifact.data.update.request",
+                artifactId: options.artifactId,
+                data: options.data,
+            },
+            responseType: "artifact.data.update.response",
+        });
+    }
+    async artifactMoveStore(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "artifact.store.move.request",
+                artifactId: options.artifactId,
+                destination: options.destination,
+            },
+            responseType: "artifact.store.move.response",
+        });
+    }
+    async deliverArchitecturalView(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "architectural-views.deliver.request",
+                workspaceId: options.workspaceId,
+                viewId: options.viewId,
+                title: options.title,
+                knowledgeReferences: options.knowledgeReferences,
+                sourcePath: options.sourcePath,
+                ...(options.quality ? { quality: options.quality } : {}),
+            },
+            responseType: "architectural-views.deliver.response",
+        });
+    }
+    async listArchitecturalViews(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "architectural-views.list.request",
+                workspaceId: options.workspaceId,
+                ...(options.knowledgeReference ? { knowledgeReference: options.knowledgeReference } : {}),
+            },
+            responseType: "architectural-views.list.response",
+        });
+    }
+    async getArchitecturalViewContent(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "architectural-views.get-content.request",
+                workspaceId: options.workspaceId,
+                viewId: options.viewId,
+            },
+            responseType: "architectural-views.get-content.response",
+        });
+    }
+    async createArchitecturalViewDraft(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "architectural-views.draft.create.request",
+                workspaceId: options.workspaceId,
+                viewId: options.viewId,
+                draftId: options.draftId,
+                title: options.title,
+                knowledgeReferences: options.knowledgeReferences,
+                ...(options.sourcePath ? { sourcePath: options.sourcePath } : {}),
+                ...(options.quality ? { quality: options.quality } : {}),
+            },
+            responseType: "architectural-views.draft.create.response",
+        });
+    }
+    async publishArchitecturalViewDraft(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "architectural-views.draft.publish.request",
+                workspaceId: options.workspaceId,
+                viewId: options.viewId,
+                draftId: options.draftId,
+            },
+            responseType: "architectural-views.draft.publish.response",
+        });
+    }
+    async updateArchitecturalViewDraft(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "architectural-views.draft.update.request",
+                workspaceId: options.workspaceId,
+                viewId: options.viewId,
+                draftId: options.draftId,
+                sourcePath: options.sourcePath,
+                ...(options.quality ? { quality: options.quality } : {}),
+            },
+            responseType: "architectural-views.draft.update.response",
+        });
+    }
+    async discardArchitecturalViewDraft(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "architectural-views.draft.discard.request",
+                workspaceId: options.workspaceId,
+                viewId: options.viewId,
+                draftId: options.draftId,
+            },
+            responseType: "architectural-views.draft.discard.response",
+        });
+    }
+    async getArchitecturalViewDraftContent(options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options.requestId,
+            message: {
+                type: "architectural-views.draft.get-content.request",
+                workspaceId: options.workspaceId,
+                viewId: options.viewId,
+                draftId: options.draftId,
+            },
+            responseType: "architectural-views.draft.get-content.response",
+        });
+    }
     onTerminalStreamEvent(handler) {
         return this.terminalStreams.onEvent(handler);
     }
@@ -6110,6 +6582,12 @@ export class DaemonClient {
     getInboundDispatchTimings(sinceMs) {
         return this.runtimeMetrics?.getInboundDispatchTimings(sinceMs) ?? [];
     }
+    requireDaemonConfigReloadSupport() {
+        // COMPAT(daemonConfigReload): added in v0.4.0, remove gate after 2027-02-14.
+        if (this.lastServerInfoMessage?.features?.daemonConfigReload !== true) {
+            throw new Error("Update the host to reload daemon configuration.");
+        }
+    }
     resolveTransportUrlForAttempt() {
         return this.config.url;
     }
@@ -6346,9 +6824,31 @@ export class DaemonClient {
             return;
         }
         if (frame.opcode === FileTransferOpcode.FileChunk) {
+            // COMPAT(fileReadByteBudget): added in v0.5.0, remove after 2027-02-21 once daemon floor >= v0.5.0.
+            // Old daemons stream despite maxBytes; discard before client-side accumulation.
+            if (transfer.maxBytes && transfer.size > transfer.maxBytes) {
+                return;
+            }
             transfer.chunks.push(frame.payload);
             return;
         }
+        // COMPAT(fileReadByteBudget): added in v0.5.0, remove after 2027-02-21 once daemon floor >= v0.5.0.
+        if (transfer.maxBytes && transfer.size > transfer.maxBytes) {
+            this.activeBinaryFileTransfers.delete(frame.requestId);
+            this.handleSessionMessage({
+                type: "file_explorer_response",
+                payload: {
+                    cwd: transfer.cwd,
+                    path: transfer.path,
+                    mode: "file",
+                    directory: null,
+                    file: null,
+                    error: "File is too large to display",
+                    requestId: frame.requestId,
+                },
+            });
+            return;
+        }
         const bytes = concatByteChunks(transfer.chunks, transfer.size);
         this.activeBinaryFileTransfers.delete(frame.requestId);
         this.completedBinaryFileReads.set(frame.requestId, {
@@ -6752,30 +7252,6 @@ export class DaemonClient {
             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) {