orchestrator-client 5.7.0 → 5.7.2

package/dist/index.js

@@ -90,6 +90,7 @@ var OrchestratorAsync = class {
     this._getToken = opts.getToken;
     this._timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     this._maxRetries = opts.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this._locale = opts.locale;
     this._fetch = opts.fetch ?? globalThis.fetch;
     if (opts.insecure && !opts.fetch && typeof process !== "undefined" && process.versions?.node) {
       this._insecure = true;
@@ -114,6 +115,9 @@ var OrchestratorAsync = class {
         headers.Authorization = `Bearer ${token}`;
       }
     }
+    if (this._locale) {
+      headers["X-Locale"] = this._locale;
+    }
     return headers;
   }
   async _request(method, path, opts) {
@@ -259,13 +263,17 @@ var OrchestratorAsync = class {
   // Tasks
   // ------------------------------------------------------------------
   async listTasks(params) {
-    const data = await this._get("/tasks", {
-      workflow_id: params?.workflowId,
-      status: params?.status,
-      limit: params?.limit,
-      offset: params?.offset,
-      sort_by: params?.sortBy,
-      sort_order: params?.sortOrder
+    const headers = {};
+    if (params?.locale) headers["X-Locale"] = params.locale;
+    const data = await this._request("GET", "/tasks", {
+      params: {
+        page: params?.page,
+        limit: params?.limit,
+        order_by: params?.orderBy,
+        order_direction: params?.orderDirection,
+        workflow_id: params?.workflowId
+      },
+      headers
     });
     const tasks = (data.tasks ?? []).map(
       buildTaskSummary
@@ -273,22 +281,36 @@ var OrchestratorAsync = class {
     return { tasks, pagination: buildPagination(data) };
   }
   async createTask(params) {
-    const data = await this._post("/tasks", {
+    const data = await this._post("/task/create", {
       workflow_id: params.workflowId,
       goal_prompt: params.goalPrompt,
       max_iterations: params.maxIterations,
-      options: params.options,
+      reasoning_effort: params.reasoningEffort,
+      system_prompt: params.systemPrompt,
+      developer_prompt: params.developerPrompt,
       ticket_id: params.ticketId,
-      title: params.title,
-      model_id: params.modelId
+      ticket_text: params.ticketText,
+      summary: params.summary,
+      problem_summary: params.problemSummary,
+      solution_strategy: params.solutionStrategy,
+      agent_model_id: params.agentModelId,
+      orchestrator_model_id: params.orchestratorModelId,
+      available_tools: params.availableTools,
+      attachment_ids: params.attachmentIds,
+      options: params.options
     });
     return {
       taskId: data.taskId ?? data.task_id ?? "",
       status: data.status ?? ""
     };
   }
-  async getTaskStatus(taskId) {
-    const data = await this._get(`/tasks/${taskId}`);
+  async getTaskStatus(taskId, locale) {
+    const headers = {};
+    if (locale) headers["X-Locale"] = locale;
+    const data = await this._request("GET", "/task/status", {
+      params: { task_id: taskId },
+      headers
+    });
     return {
       ...buildTaskSummary(data),
       subtaskIds: data.subtaskIds ?? data.subtask_ids ?? [],
@@ -296,10 +318,24 @@ var OrchestratorAsync = class {
       options: data.options ?? null
     };
   }
-  async getTaskConversation(taskId) {
-    const data = await this._get(
-      `/tasks/${taskId}/conversation`
-    );
+  async setTaskStatus(taskId, status) {
+    const data = await this._post("/task/set_status", {
+      task_id: taskId,
+      status
+    });
+    return { message: data.message ?? "" };
+  }
+  async getTaskConversation(taskId, params) {
+    const headers = {};
+    if (params?.locale) headers["X-Locale"] = params.locale;
+    const data = await this._request("GET", "/task/conversation", {
+      params: {
+        task_id: taskId,
+        include_summaries: params?.includeSummaries,
+        exclude_archived: params?.excludeArchived
+      },
+      headers
+    });
     return {
       taskId: data.taskId ?? data.task_id ?? taskId,
       conversation: (data.conversation ?? []).map((m) => m)
@@ -307,19 +343,19 @@ var OrchestratorAsync = class {
   }
   async getArchivedMessageContent(taskId, messageId) {
     return this._get(
-      `/tasks/${taskId}/conversation/messages/${messageId}/archived`
+      "/task/message/archived-content",
+      { task_id: taskId, message_id: messageId }
     );
   }
   async getTaskCompactions(taskId) {
-    const data = await this._get(
-      `/tasks/${taskId}/compactions`
-    );
-    return data.compactions ?? [];
+    return this._get("/task/compactions", {
+      task_id: taskId
+    });
   }
   async getTaskJournal(taskId) {
-    const data = await this._get(
-      `/tasks/${taskId}/journal`
-    );
+    const data = await this._get("/task/journal", {
+      task_id: taskId
+    });
     return {
       taskId: data.taskId ?? data.task_id ?? taskId,
       exists: data.exists ?? false,
@@ -330,15 +366,22 @@ var OrchestratorAsync = class {
     };
   }
   async cancelTask(taskId) {
-    const data = await this._post(
-      `/tasks/${taskId}/cancel`
-    );
-    return { message: data.message ?? "" };
+    const data = await this._post("/task/cancel", {
+      task_id: taskId
+    });
+    return {
+      taskId: data.taskId ?? data.task_id ?? taskId,
+      killed: data.killed ?? false,
+      via: data.via ?? "none",
+      holderId: data.holderId ?? data.holder_id ?? void 0,
+      reason: data.reason ?? void 0,
+      message: data.message ?? ""
+    };
   }
   async deleteTask(taskId) {
-    const data = await this._delete(
-      `/tasks/${taskId}`
-    );
+    const data = await this._post("/task/delete", {
+      task_id: taskId
+    });
     return {
       deletedTasks: data.deletedTasks ?? data.deleted_tasks ?? [],
       failedTasks: data.failedTasks ?? data.failed_tasks ?? [],
@@ -347,9 +390,10 @@ var OrchestratorAsync = class {
     };
   }
   async deleteTasks(taskIds) {
-    const data = await this._post("/tasks/delete", {
-      task_ids: taskIds
-    });
+    const data = await this._post(
+      "/task/delete/multiple",
+      { task_ids: taskIds }
+    );
     return {
       deletedTasks: data.deletedTasks ?? data.deleted_tasks ?? [],
       failedTasks: data.failedTasks ?? data.failed_tasks ?? [],
@@ -360,18 +404,15 @@ var OrchestratorAsync = class {
   // ------------------------------------------------------------------
   // Attachments
   // ------------------------------------------------------------------
-  async uploadAttachment(taskId, file, filename) {
+  async uploadAttachment(file, filename) {
     const formData = new FormData();
     formData.append("file", file, filename);
     const headers = await this._resolveHeaders();
-    const response = await this._fetch(
-      this._makeUrl(`/tasks/${taskId}/attachments`),
-      {
-        method: "POST",
-        headers: { ...headers },
-        body: formData
-      }
-    );
+    const response = await this._fetch(this._makeUrl("/attachment"), {
+      method: "POST",
+      headers: { ...headers },
+      body: formData
+    });
     if (!response.ok) {
       throw new OrchestratorAPIError(
         `Attachment upload failed: ${response.statusText}`,
@@ -389,13 +430,11 @@ var OrchestratorAsync = class {
       tokenCount: data.tokenCount ?? data.token_count ?? null
     };
   }
-  async downloadAttachment(taskId, attachmentId) {
+  async downloadAttachment(attachmentId) {
     const headers = await this._resolveHeaders();
     const response = await this._fetch(
-      this._makeUrl(`/tasks/${taskId}/attachments/${attachmentId}`),
-      {
-        headers
-      }
+      this._makeUrl(`/attachment/${attachmentId}`),
+      { headers }
     );
     if (!response.ok) {
       throw new OrchestratorAPIError(
@@ -408,126 +447,135 @@ var OrchestratorAsync = class {
   // ------------------------------------------------------------------
   // Interactive workflow
   // ------------------------------------------------------------------
-  async sendInteractiveMessage(taskId, content) {
+  async sendInteractiveMessage(taskId, message, attachmentIds) {
     const data = await this._post(
-      `/tasks/${taskId}/interactive/message`,
-      {
-        content
-      }
+      "/task/interactive/message",
+      { task_id: taskId, message, attachment_ids: attachmentIds }
     );
     return { message: data.message ?? "" };
   }
   async markInteractiveComplete(taskId) {
     const data = await this._post(
-      `/tasks/${taskId}/interactive/complete`
+      "/task/interactive/mark_complete",
+      { task_id: taskId }
     );
     return { message: data.message ?? "" };
   }
   async markInteractiveFailed(taskId) {
     const data = await this._post(
-      `/tasks/${taskId}/interactive/failed`
+      "/task/interactive/mark_failed",
+      { task_id: taskId }
     );
     return { message: data.message ?? "" };
   }
-  async approveInteractiveAction(taskId) {
+  async approveInteractiveAction(taskId, approved = true) {
     const data = await this._post(
-      `/tasks/${taskId}/interactive/approve`
+      "/task/interactive/action",
+      { task_id: taskId, approved }
+    );
+    return { message: data.message ?? "" };
+  }
+  async stopInteractive(taskId) {
+    const data = await this._post(
+      "/task/interactive/stop",
+      { task_id: taskId }
     );
     return { message: data.message ?? "" };
   }
   // ------------------------------------------------------------------
   // Proactive workflow
   // ------------------------------------------------------------------
-  async sendProactiveGuide(taskId, guide) {
+  async sendProactiveGuide(taskId, message, attachmentIds) {
     const data = await this._post(
-      `/tasks/${taskId}/proactive/guide`,
-      {
-        guide
-      }
+      "/task/proactive/guide",
+      { task_id: taskId, message, attachment_ids: attachmentIds }
     );
     return { message: data.message ?? "" };
   }
   async respondProactiveHelp(taskId, response) {
     const data = await this._post(
-      `/tasks/${taskId}/proactive/respond`,
-      {
-        response
-      }
+      "/task/proactive/help",
+      { task_id: taskId, response }
     );
     return { message: data.message ?? "" };
   }
-  async approveProactiveAction(taskId) {
+  async approveProactiveAction(taskId, approved = true) {
     const data = await this._post(
-      `/tasks/${taskId}/proactive/approve`
+      "/task/proactive/action",
+      { task_id: taskId, approved }
     );
     return { message: data.message ?? "" };
   }
   // ------------------------------------------------------------------
   // Ticket workflow
   // ------------------------------------------------------------------
-  async sendTicketGuide(taskId, guide) {
+  async sendTicketGuide(taskId, message, attachmentIds) {
     const data = await this._post(
-      `/tasks/${taskId}/ticket/guide`,
-      {
-        guide
-      }
+      "/task/ticket/guide",
+      { task_id: taskId, message, attachment_ids: attachmentIds }
     );
     return { message: data.message ?? "" };
   }
   async respondTicketHelp(taskId, response) {
     const data = await this._post(
-      `/tasks/${taskId}/ticket/respond`,
-      {
-        response
-      }
+      "/task/ticket/help",
+      { task_id: taskId, response }
     );
     return { message: data.message ?? "" };
   }
-  async approveTicketAction(taskId) {
+  async approveTicketAction(taskId, approved = true) {
     const data = await this._post(
-      `/tasks/${taskId}/ticket/approve`
+      "/task/ticket/action",
+      { task_id: taskId, approved }
     );
     return { message: data.message ?? "" };
   }
   async wakeTicket(taskId) {
     const data = await this._post(
-      `/tasks/${taskId}/ticket/wake`
+      "/task/ticket/wake",
+      { task_id: taskId }
     );
     return { message: data.message ?? "" };
   }
   // ------------------------------------------------------------------
   // Matrix workflow
   // ------------------------------------------------------------------
-  async sendMatrixMessage(taskId, content) {
+  async sendMatrixMessage(taskId, message, attachmentIds) {
     const data = await this._post(
-      `/tasks/${taskId}/matrix/message`,
-      {
-        content
-      }
+      "/task/matrix/message",
+      { task_id: taskId, message, attachment_ids: attachmentIds }
     );
     return { message: data.message ?? "" };
   }
   async markMatrixComplete(taskId) {
     const data = await this._post(
-      `/tasks/${taskId}/matrix/complete`
+      "/task/matrix/mark_complete",
+      { task_id: taskId }
     );
     return { message: data.message ?? "" };
   }
   async markMatrixFailed(taskId) {
     const data = await this._post(
-      `/tasks/${taskId}/matrix/failed`
+      "/task/matrix/mark_failed",
+      { task_id: taskId }
     );
     return { message: data.message ?? "" };
   }
-  async approveMatrixAction(taskId) {
+  async approveMatrixAction(taskId, approved = true) {
     const data = await this._post(
-      `/tasks/${taskId}/matrix/approve`
+      "/task/matrix/action",
+      { task_id: taskId, approved }
     );
     return { message: data.message ?? "" };
   }
-  async getMatrixConversation(taskId) {
+  async getMatrixConversation(taskId, phase, includeSummaries) {
     const data = await this._get(
-      `/tasks/${taskId}/matrix/conversation`
+      "/task/matrix/conversation",
+      {
+        task_id: taskId,
+        phase,
+        include_summaries: includeSummaries
+      }
     );
     return {
       taskId: data.taskId ?? data.task_id ?? taskId,
@@ -539,72 +587,84 @@ var OrchestratorAsync = class {
   // ------------------------------------------------------------------
   async createVSATask(params) {
     const body = {
+      user_id: params.userId,
       goal_prompt: params.goalPrompt,
       title: params.title,
-      model_id: params.modelId
+      agent_model_id: params.agentModelId,
+      orchestrator_model_id: params.orchestratorModelId,
+      attachment_ids: params.attachmentIds,
+      options: params.options
     };
     if (params.delegatedToken !== void 0) {
       body.delegated_token = params.delegatedToken;
     }
-    const data = await this._post("/tasks/vsa", body);
+    const data = await this._post(
+      "/task/vsa/create",
+      body
+    );
     return {
       taskId: data.taskId ?? data.task_id ?? "",
       status: data.status ?? ""
     };
   }
-  async sendVSAMessage(taskId, content, options) {
-    const body = { content };
+  async sendVSAMessage(taskId, message, options) {
+    const body = {
+      task_id: taskId,
+      message,
+      attachment_ids: options?.attachmentIds
+    };
     if (options?.delegatedToken !== void 0) {
       body.delegated_token = options.delegatedToken;
     }
     const data = await this._post(
-      `/tasks/${taskId}/vsa/message`,
+      "/task/vsa/message",
       body
     );
     return { message: data.message ?? "" };
   }
   async renameVSATask(taskId, title) {
-    const data = await this._post(
-      `/tasks/${taskId}/vsa/rename`,
-      {
-        title
-      }
-    );
+    const data = await this._post("/task/vsa/rename", {
+      task_id: taskId,
+      title
+    });
     return { message: data.message ?? "" };
   }
   async regenerateVSATitle(taskId) {
     const data = await this._post(
-      `/tasks/${taskId}/vsa/regenerate-title`
+      "/task/vsa/regenerate_title",
+      { task_id: taskId }
     );
     return { message: data.message ?? "" };
   }
   async markVSAComplete(taskId) {
     const data = await this._post(
-      `/tasks/${taskId}/vsa/complete`
+      "/task/vsa/mark_complete",
+      { task_id: taskId }
     );
     return { message: data.message ?? "" };
   }
   async markVSAFailed(taskId) {
     const data = await this._post(
-      `/tasks/${taskId}/vsa/failed`
+      "/task/vsa/mark_failed",
+      { task_id: taskId }
     );
     return { message: data.message ?? "" };
   }
   async stopVSA(taskId) {
-    const data = await this._post(
-      `/tasks/${taskId}/vsa/stop`
-    );
+    const data = await this._post("/task/vsa/stop", {
+      task_id: taskId
+    });
     return { message: data.message ?? "" };
   }
   async deleteVSA(taskId) {
-    const data = await this._delete(
-      `/tasks/${taskId}/vsa`
-    );
+    const data = await this._post("/task/vsa/delete", {
+      task_id: taskId
+    });
     return { message: data.message ?? "" };
   }
-  async listVSATasks(params) {
-    const data = await this._get("/tasks/vsa", {
-      status: params?.status,
+  async listVSATasks(userId, params) {
+    const data = await this._get("/task/vsa/list", {
+      user_id: userId,
       limit: params?.limit,
       offset: params?.offset
     });
@@ -613,9 +673,11 @@ var OrchestratorAsync = class {
     );
     return { tasks, pagination: buildPagination(data) };
   }
-  async searchVSATasks(query) {
-    const data = await this._get("/tasks/vsa/search", {
-      q: query
+  async searchVSATasks(userId, query, limit) {
+    const data = await this._get("/task/vsa/search", {
+      user_id: userId,
+      query,
+      limit
     });
     const tasks = (data.tasks ?? []).map(
       buildTaskSummary
@@ -624,91 +686,123 @@ var OrchestratorAsync = class {
   }
   async deleteVSATasksBulk(taskIds) {
     const data = await this._post(
-      "/tasks/vsa/delete-bulk",
-      {
-        task_ids: taskIds
-      }
+      "/task/vsa/delete_bulk",
+      { task_ids: taskIds }
     );
-    return { message: data.message ?? "" };
+    return {
+      deletedTasks: data.deletedTasks ?? data.deleted_tasks ?? [],
+      failedTasks: data.failedTasks ?? data.failed_tasks ?? [],
+      totalDeleted: data.totalDeleted ?? data.total_deleted ?? 0,
+      totalFailed: data.totalFailed ?? data.total_failed ?? 0
+    };
   }
   // ------------------------------------------------------------------
-  // MIO workflow
+  // MIO (self_managed) workflow
   // ------------------------------------------------------------------
-  async sendMioMessage(taskId, content) {
+  async sendMioMessage(taskId, message, attachmentIds) {
     const data = await this._post(
-      `/tasks/${taskId}/mio/message`,
-      {
-        content
-      }
+      "/task/self_managed/message",
+      { task_id: taskId, message, attachment_ids: attachmentIds }
     );
     return { message: data.message ?? "" };
   }
-  async approveMioAction(taskId) {
+  async approveMioAction(taskId, approved = true, feedback) {
     const data = await this._post(
-      `/tasks/${taskId}/mio/approve`
+      "/task/self_managed/action",
+      { task_id: taskId, approved, feedback }
     );
     return { message: data.message ?? "" };
   }
   async wakeMio(taskId) {
     const data = await this._post(
-      `/tasks/${taskId}/mio/wake`
+      "/task/self_managed/wake",
+      { task_id: taskId }
     );
     return { message: data.message ?? "" };
   }
   async sendMioUserAway(taskId) {
     const data = await this._post(
-      `/tasks/${taskId}/mio/user-away`
+      "/task/self_managed/user_away",
+      { task_id: taskId }
     );
     return { message: data.message ?? "" };
   }
   async markMioComplete(taskId) {
     const data = await this._post(
-      `/tasks/${taskId}/mio/complete`
+      "/task/self_managed/mark_complete",
+      { task_id: taskId }
     );
     return { message: data.message ?? "" };
   }
   async markMioFailed(taskId) {
     const data = await this._post(
-      `/tasks/${taskId}/mio/failed`
+      "/task/self_managed/mark_failed",
+      { task_id: taskId }
     );
     return { message: data.message ?? "" };
   }
   async archiveMio(taskId) {
     const data = await this._post(
-      `/tasks/${taskId}/mio/archive`
+      "/task/self_managed/archive",
+      { task_id: taskId }
     );
     return { message: data.message ?? "" };
   }
   async getMioContext(taskId) {
     const data = await this._get(
-      `/tasks/${taskId}/mio/context`
+      "/task/self_managed/context",
+      { task_id: taskId }
     );
     return {
       taskId: data.taskId ?? data.task_id ?? taskId,
+      modelId: data.modelId ?? data.model_id ?? "",
       currentTokens: data.currentTokens ?? data.current_tokens ?? 0,
       contextLimit: data.contextLimit ?? data.context_limit ?? 0,
       usagePercentage: data.usagePercentage ?? data.usage_percentage ?? 0,
-      archivedCount: data.archivedCount ?? data.archived_count ?? 0,
-      activeCount: data.activeCount ?? data.active_count ?? 0
+      totalMessages: data.totalMessages ?? data.total_messages ?? 0,
+      activeMessages: data.activeMessages ?? data.active_messages ?? 0,
+      archivedMessages: data.archivedMessages ?? data.archived_messages ?? 0,
+      messagesWithoutTokenCount: data.messagesWithoutTokenCount ?? data.messages_without_token_count ?? 0
+    };
+  }
+  async getMioMemories(taskId, includeCommon) {
+    const data = await this._get(
+      "/task/self_managed/memories",
+      { task_id: taskId, include_common: includeCommon }
+    );
+    return {
+      memories: data.memories ?? [],
+      total: data.total ?? 0
     };
   }
   // ------------------------------------------------------------------
   // Tools
   // ------------------------------------------------------------------
   async listTools() {
-    const data = await this._get("/tools");
+    const data = await this._get("/tools/all");
     return {
-      tools: (data.tools ?? data.tools ?? []).map((t) => t),
+      tools: (data.tools ?? []).map(
+        (t) => t
+      ),
       totalTools: data.totalTools ?? data.total_tools ?? 0,
       servers: data.servers ?? []
     };
   }
+  async getToolCatalog() {
+    return this._get("/tools/catalog");
+  }
+  async refreshMCPTools() {
+    return this._post("/tools/mcp/refresh");
+  }
+  async validateToolCatalog() {
+    return this._get("/tools/validate");
+  }
   // ------------------------------------------------------------------
   // Debug / Admin
   // ------------------------------------------------------------------
   async getWorkflowStates() {
     const data = await this._get(
-      "/debug/workflow-states"
+      "/debug/workflow_states"
     );
     return {
       validStates: data.validStates ?? data.valid_states ?? {},
@@ -720,65 +814,65 @@ var OrchestratorAsync = class {
   }
   async updateTaskModels(taskId, models) {
     const data = await this._post(
-      `/tasks/${taskId}/models`,
+      "/debug/task/models",
       {
-        agent: models.agent,
-        orchestrator: models.orchestrator
+        task_id: taskId,
+        agent_model_id: models.agentModelId,
+        orchestrator_model_id: models.orchestratorModelId
       }
     );
     return { message: data.message ?? "" };
   }
-  async updateTaskIteration(taskId, iteration) {
+  async updateTaskIteration(taskId, iteration, maxIterations) {
     const data = await this._post(
-      `/tasks/${taskId}/iteration`,
-      {
-        iteration
-      }
+      "/debug/task/iteration",
+      { task_id: taskId, iteration, max_iterations: maxIterations }
     );
     return { message: data.message ?? "" };
   }
   async updateTaskWorkflowData(taskId, workflowData) {
     const data = await this._post(
-      `/tasks/${taskId}/workflow-data`,
-      {
-        workflow_data: workflowData
-      }
+      "/debug/task/workflow_data",
+      { task_id: taskId, workflow_data: workflowData }
     );
     return { message: data.message ?? "" };
   }
   async deleteMessage(taskId, messageId) {
-    const data = await this._delete(
-      `/tasks/${taskId}/conversation/messages/${messageId}`
+    const data = await this._post(
+      "/debug/task/message/delete",
+      { task_id: taskId, message_id: messageId }
     );
     return { message: data.message ?? "" };
   }
   async deleteMessages(taskId, messageIds) {
     const data = await this._post(
-      `/tasks/${taskId}/conversation/messages/delete`,
-      { message_ids: messageIds }
+      "/debug/task/message/delete/multiple",
+      { task_id: taskId, message_ids: messageIds }
     );
-    return { message: data.message ?? "" };
+    return {
+      deletedIds: data.deletedIds ?? data.deleted_ids ?? [],
+      failedIds: data.failedIds ?? data.failed_ids ?? [],
+      totalDeleted: data.totalDeleted ?? data.total_deleted ?? 0,
+      totalFailed: data.totalFailed ?? data.total_failed ?? 0
+    };
   }
   async updateMessage(taskId, messageId, update) {
-    const data = await this._put(
-      `/tasks/${taskId}/conversation/messages/${messageId}`,
-      update
+    const data = await this._post(
+      "/debug/task/message/update",
+      { task_id: taskId, message_id: messageId, ...update }
     );
     return { message: data.message ?? "" };
   }
   async resetMatrixToPhase(taskId, phase) {
     const data = await this._post(
-      `/tasks/${taskId}/matrix/reset`,
-      { phase }
+      "/debug/task/matrix/reset_to_phase",
+      { task_id: taskId, phase }
     );
     return { message: data.message ?? "" };
   }
-  async getMessageTranslations(taskId, messageId, locale) {
-    const params = {};
-    if (locale) params.locale = locale;
+  async getMessageTranslations(taskId, messageId) {
     const data = await this._get(
-      `/tasks/${taskId}/conversation/messages/${messageId}/translations`,
-      params
+      `/debug/task/${taskId}/message/${messageId}/translations`
     );
     return {
       messageId: data.messageId ?? data.message_id ?? messageId,
@@ -789,25 +883,54 @@ var OrchestratorAsync = class {
   // Error events
   // ------------------------------------------------------------------
   async listErrors(params) {
-    const queryParams = {};
-    if (params?.since) queryParams.since = params.since;
-    if (params?.severity) queryParams.severity = params.severity;
-    if (params?.source) queryParams.source = params.source;
-    if (params?.limit) queryParams.limit = params.limit;
-    if (params?.offset) queryParams.offset = params.offset;
-    const data = await this._get(
-      "/errors",
-      queryParams
-    );
-    return (data.errors ?? []).map(
-      (e) => e
-    );
+    const authHeaders = await this._resolveHeaders();
+    const url = new URL(this._makeUrl("/errors"));
+    if (params?.page !== void 0)
+      url.searchParams.set("page", String(params.page));
+    if (params?.limit !== void 0)
+      url.searchParams.set("limit", String(params.limit));
+    if (params?.taskId) url.searchParams.set("task_id", params.taskId);
+    if (params?.workflowId)
+      url.searchParams.set("workflow_id", params.workflowId);
+    if (params?.errorCode) url.searchParams.set("error_code", params.errorCode);
+    if (params?.exceptionType)
+      url.searchParams.set("exception_type", params.exceptionType);
+    if (params?.holderId) url.searchParams.set("holder_id", params.holderId);
+    if (params?.requestId) url.searchParams.set("request_id", params.requestId);
+    if (params?.search) url.searchParams.set("search", params.search);
+    if (params?.since) url.searchParams.set("since", params.since);
+    if (params?.until) url.searchParams.set("until", params.until);
+    if (params?.orderDirection)
+      url.searchParams.set("order_direction", params.orderDirection);
+    for (const s of params?.severity ?? []) {
+      url.searchParams.append("severity", s);
+    }
+    for (const s of params?.source ?? []) {
+      url.searchParams.append("source", s);
+    }
+    const response = await this._fetch(url.toString(), {
+      method: "GET",
+      headers: { ...authHeaders }
+    });
+    if (!response.ok) {
+      throw new OrchestratorAPIError(
+        `listErrors failed: ${response.statusText}`,
+        response.status
+      );
+    }
+    const data = await response.json();
+    return {
+      items: (data.items ?? data.errors ?? []).map((e) => e),
+      pagination: buildPagination(data)
+    };
   }
   async getErrorDetail(errorId) {
     return this._get(`/errors/${errorId}`);
   }
-  async getErrorStats(since) {
-    const params = {};
+  async getErrorStats(since, topN = 10) {
+    const params = {
+      top_n: topN
+    };
     if (since) params.since = since;
     return this._get("/errors/stats", params);
   }
@@ -826,13 +949,13 @@ var OrchestratorAsync = class {
     return this._get("/health");
   }
   async healthDetailed() {
-    return this._get("/health/detail");
+    return this._get("/health/detailed");
   }
   async ready() {
     return this._get("/ready");
   }
   async healthLeader() {
-    return this._get("/leader");
+    return this._get("/health/leader");
   }
   async getMetrics(types) {
     const params = {};
@@ -843,107 +966,122 @@ var OrchestratorAsync = class {
   // Configuration
   // ------------------------------------------------------------------
   async getSystemStatus() {
-    return this._get("/config/status");
+    return this._get("/configuration/system/status");
   }
   async updateSettings(settings) {
-    return this._post("/config/settings", settings);
+    return this._post("/configuration/system/settings", settings);
   }
   async getConfigurationStatus() {
-    return this._get("/config");
+    return this._get("/configuration/status");
   }
   async setAgentModel(model) {
     const data = await this._post(
-      "/config/models/agent",
-      { model }
+      "/configuration/agent",
+      { model_name: model }
     );
     return { message: data.message ?? "" };
   }
   async setOrchestratorModel(model) {
     const data = await this._post(
-      "/config/models/orchestrator",
-      { model }
+      "/configuration/orchestrator",
+      { model_name: model }
     );
     return { message: data.message ?? "" };
   }
   async getLLMBackendStatus() {
-    return this._get("/config/llmbackends");
+    return this._get(
+      "/configuration/llmbackend/status"
+    );
   }
   async addLLMBackend(host, apiKey) {
     const data = await this._post(
-      "/config/llmbackends",
-      {
-        host,
-        api_key: apiKey
-      }
+      "/configuration/llmbackend/add",
+      { backends: [{ url: host, api_key: apiKey }] }
     );
     return { message: data.message ?? "" };
   }
   async removeLLMBackend(host) {
-    const data = await this._delete(
-      `/config/llmbackends/${encodeURIComponent(host)}`
+    const data = await this._post(
+      "/configuration/llmbackend/remove",
+      { host }
     );
     return { message: data.message ?? "" };
   }
   async getMCPServerStatus() {
-    return this._get("/config/mcpservers");
+    return this._get(
+      "/configuration/mcpserver/status"
+    );
   }
   async addMCPServer(host, apiKey) {
     const data = await this._post(
-      "/config/mcpservers",
-      {
-        host,
-        api_key: apiKey
-      }
+      "/configuration/mcpserver/add",
+      { servers: [{ url: host, api_key: apiKey }] }
     );
     return { message: data.message ?? "" };
   }
   async removeMCPServer(host) {
-    const data = await this._delete(
-      `/config/mcpservers/${encodeURIComponent(host)}`
+    const data = await this._post(
+      "/configuration/mcpserver/remove",
+      { host }
     );
     return { message: data.message ?? "" };
   }
   async getTaskHandlerStatus() {
-    return this._get("/config/taskhandler");
+    return this._get("/configuration/taskhandler/status");
   }
   async getTaskHandlerStatusLocal() {
-    return this._get("/config/taskhandler/local");
+    return this._get(
+      "/configuration/taskhandler/status/local"
+    );
   }
   async setConcurrentTasksPerReplica(maxTasks) {
-    const data = await this._post(
-      "/config/taskhandler/concurrency",
-      {
-        max_tasks: maxTasks
-      }
+    const data = await this._request(
+      "POST",
+      "/configuration/taskhandler/concurrent-per-replica",
+      { params: { max_tasks: maxTasks } }
     );
     return { message: data.message ?? "" };
   }
   async getSummaryWorkerStatus() {
-    return this._get("/config/summary-worker");
+    return this._get(
+      "/configuration/summary-worker/status"
+    );
   }
   async setCompactorModel(modelName) {
     const data = await this._post(
-      "/config/models/compactor",
-      {
-        model_name: modelName
-      }
+      "/configuration/summary-worker/model",
+      { model_name: modelName }
     );
     return { message: data.message ?? "" };
   }
   async setTranslateModel(modelName) {
     const data = await this._post(
-      "/config/models/translate",
-      {
-        model_name: modelName
-      }
+      "/configuration/summary-worker/translate-model",
+      { model_name: modelName }
     );
     return { message: data.message ?? "" };
   }
   async getTokenWorkerStatus() {
-    return this._get("/config/token-worker");
+    return this._get("/configuration/token-worker/status");
   }
   async getSlotsStatus() {
-    return this._get("/config/slots");
+    return this._get("/configuration/slots/status");
+  }
+  async getSubagentsStatus() {
+    return this._get("/configuration/subagents/status");
+  }
+  async setSubagentsEnabled(enabled) {
+    const data = await this._post(
+      "/configuration/subagents",
+      { enabled }
+    );
+    return { message: data.message ?? "" };
+  }
+  async reloadServices() {
+    return this._post("/configuration/reload");
+  }
+  async getReloadStatus() {
+    return this._get("/configuration/reload/status");
   }
   // ------------------------------------------------------------------
   // Auth / WebSocket status
@@ -961,10 +1099,10 @@ var OrchestratorAsync = class {
     const headers = await this._resolveHeaders();
     headers.Accept = "text/event-stream";
     const response = await this._fetch(
-      this._makeUrl(`/tasks/${taskId}/stream`),
-      {
-        headers
-      }
+      this._makeUrl(
+        `/task/stream_status?task_id=${encodeURIComponent(taskId)}`
+      ),
+      { headers }
     );
     if (!response.ok) {
       throw new OrchestratorAPIError(
@@ -1031,11 +1169,14 @@ var Orchestrator = class {
   createTask(params) {
     return runSync(this._async.createTask(params));
   }
-  getTaskStatus(taskId) {
-    return runSync(this._async.getTaskStatus(taskId));
+  getTaskStatus(taskId, locale) {
+    return runSync(this._async.getTaskStatus(taskId, locale));
   }
-  getTaskConversation(taskId) {
-    return runSync(this._async.getTaskConversation(taskId));
+  setTaskStatus(taskId, status) {
+    return runSync(this._async.setTaskStatus(taskId, status));
+  }
+  getTaskConversation(taskId, params) {
+    return runSync(this._async.getTaskConversation(taskId, params));
   }
   getArchivedMessageContent(taskId, messageId) {
     return runSync(this._async.getArchivedMessageContent(taskId, messageId));
@@ -1058,17 +1199,19 @@ var Orchestrator = class {
   // ------------------------------------------------------------------
   // Attachments
   // ------------------------------------------------------------------
-  uploadAttachment(taskId, file, filename) {
-    return runSync(this._async.uploadAttachment(taskId, file, filename));
+  uploadAttachment(file, filename) {
+    return runSync(this._async.uploadAttachment(file, filename));
   }
-  downloadAttachment(taskId, attachmentId) {
-    return runSync(this._async.downloadAttachment(taskId, attachmentId));
+  downloadAttachment(attachmentId) {
+    return runSync(this._async.downloadAttachment(attachmentId));
   }
   // ------------------------------------------------------------------
   // Interactive workflow
   // ------------------------------------------------------------------
-  sendInteractiveMessage(taskId, content) {
-    return runSync(this._async.sendInteractiveMessage(taskId, content));
+  sendInteractiveMessage(taskId, message, attachmentIds) {
+    return runSync(
+      this._async.sendInteractiveMessage(taskId, message, attachmentIds)
+    );
   }
   markInteractiveComplete(taskId) {
     return runSync(this._async.markInteractiveComplete(taskId));
@@ -1076,32 +1219,37 @@ var Orchestrator = class {
   markInteractiveFailed(taskId) {
     return runSync(this._async.markInteractiveFailed(taskId));
   }
-  approveInteractiveAction(taskId) {
-    return runSync(this._async.approveInteractiveAction(taskId));
+  approveInteractiveAction(taskId, approved = true) {
+    return runSync(this._async.approveInteractiveAction(taskId, approved));
+  }
+  stopInteractive(taskId) {
+    return runSync(this._async.stopInteractive(taskId));
   }
   // ------------------------------------------------------------------
   // Proactive workflow
   // ------------------------------------------------------------------
-  sendProactiveGuide(taskId, guide) {
-    return runSync(this._async.sendProactiveGuide(taskId, guide));
+  sendProactiveGuide(taskId, message, attachmentIds) {
+    return runSync(
+      this._async.sendProactiveGuide(taskId, message, attachmentIds)
+    );
   }
   respondProactiveHelp(taskId, response) {
     return runSync(this._async.respondProactiveHelp(taskId, response));
   }
-  approveProactiveAction(taskId) {
-    return runSync(this._async.approveProactiveAction(taskId));
+  approveProactiveAction(taskId, approved = true) {
+    return runSync(this._async.approveProactiveAction(taskId, approved));
   }
   // ------------------------------------------------------------------
   // Ticket workflow
   // ------------------------------------------------------------------
-  sendTicketGuide(taskId, guide) {
-    return runSync(this._async.sendTicketGuide(taskId, guide));
+  sendTicketGuide(taskId, message, attachmentIds) {
+    return runSync(this._async.sendTicketGuide(taskId, message, attachmentIds));
   }
   respondTicketHelp(taskId, response) {
     return runSync(this._async.respondTicketHelp(taskId, response));
   }
-  approveTicketAction(taskId) {
-    return runSync(this._async.approveTicketAction(taskId));
+  approveTicketAction(taskId, approved = true) {
+    return runSync(this._async.approveTicketAction(taskId, approved));
   }
   wakeTicket(taskId) {
     return runSync(this._async.wakeTicket(taskId));
@@ -1109,8 +1257,10 @@ var Orchestrator = class {
   // ------------------------------------------------------------------
   // Matrix workflow
   // ------------------------------------------------------------------
-  sendMatrixMessage(taskId, content) {
-    return runSync(this._async.sendMatrixMessage(taskId, content));
+  sendMatrixMessage(taskId, message, attachmentIds) {
+    return runSync(
+      this._async.sendMatrixMessage(taskId, message, attachmentIds)
+    );
   }
   markMatrixComplete(taskId) {
     return runSync(this._async.markMatrixComplete(taskId));
@@ -1118,11 +1268,13 @@ var Orchestrator = class {
   markMatrixFailed(taskId) {
     return runSync(this._async.markMatrixFailed(taskId));
   }
-  approveMatrixAction(taskId) {
-    return runSync(this._async.approveMatrixAction(taskId));
+  approveMatrixAction(taskId, approved = true) {
+    return runSync(this._async.approveMatrixAction(taskId, approved));
   }
-  getMatrixConversation(taskId) {
-    return runSync(this._async.getMatrixConversation(taskId));
+  getMatrixConversation(taskId, phase, includeSummaries) {
+    return runSync(
+      this._async.getMatrixConversation(taskId, phase, includeSummaries)
+    );
   }
   // ------------------------------------------------------------------
   // VSA workflow
@@ -1130,8 +1282,8 @@ var Orchestrator = class {
   createVSATask(params) {
     return runSync(this._async.createVSATask(params));
   }
-  sendVSAMessage(taskId, content, options) {
-    return runSync(this._async.sendVSAMessage(taskId, content, options));
+  sendVSAMessage(taskId, message, options) {
+    return runSync(this._async.sendVSAMessage(taskId, message, options));
   }
   renameVSATask(taskId, title) {
     return runSync(this._async.renameVSATask(taskId, title));
@@ -1151,23 +1303,23 @@ var Orchestrator = class {
   deleteVSA(taskId) {
     return runSync(this._async.deleteVSA(taskId));
   }
-  listVSATasks(params) {
-    return runSync(this._async.listVSATasks(params));
+  listVSATasks(userId, params) {
+    return runSync(this._async.listVSATasks(userId, params));
   }
-  searchVSATasks(query) {
-    return runSync(this._async.searchVSATasks(query));
+  searchVSATasks(userId, query, limit) {
+    return runSync(this._async.searchVSATasks(userId, query, limit));
   }
   deleteVSATasksBulk(taskIds) {
     return runSync(this._async.deleteVSATasksBulk(taskIds));
   }
   // ------------------------------------------------------------------
-  // MIO workflow
+  // MIO (self_managed) workflow
   // ------------------------------------------------------------------
-  sendMioMessage(taskId, content) {
-    return runSync(this._async.sendMioMessage(taskId, content));
+  sendMioMessage(taskId, message, attachmentIds) {
+    return runSync(this._async.sendMioMessage(taskId, message, attachmentIds));
   }
-  approveMioAction(taskId) {
-    return runSync(this._async.approveMioAction(taskId));
+  approveMioAction(taskId, approved = true, feedback) {
+    return runSync(this._async.approveMioAction(taskId, approved, feedback));
   }
   wakeMio(taskId) {
     return runSync(this._async.wakeMio(taskId));
@@ -1187,12 +1339,24 @@ var Orchestrator = class {
   getMioContext(taskId) {
     return runSync(this._async.getMioContext(taskId));
   }
+  getMioMemories(taskId, includeCommon) {
+    return runSync(this._async.getMioMemories(taskId, includeCommon));
+  }
   // ------------------------------------------------------------------
   // Tools
   // ------------------------------------------------------------------
   listTools() {
     return runSync(this._async.listTools());
   }
+  getToolCatalog() {
+    return runSync(this._async.getToolCatalog());
+  }
+  refreshMCPTools() {
+    return runSync(this._async.refreshMCPTools());
+  }
+  validateToolCatalog() {
+    return runSync(this._async.validateToolCatalog());
+  }
   // ------------------------------------------------------------------
   // Debug / Admin
   // ------------------------------------------------------------------
@@ -1202,8 +1366,10 @@ var Orchestrator = class {
   updateTaskModels(taskId, models) {
     return runSync(this._async.updateTaskModels(taskId, models));
   }
-  updateTaskIteration(taskId, iteration) {
-    return runSync(this._async.updateTaskIteration(taskId, iteration));
+  updateTaskIteration(taskId, iteration, maxIterations) {
+    return runSync(
+      this._async.updateTaskIteration(taskId, iteration, maxIterations)
+    );
   }
   updateTaskWorkflowData(taskId, workflowData) {
     return runSync(this._async.updateTaskWorkflowData(taskId, workflowData));
@@ -1220,10 +1386,8 @@ var Orchestrator = class {
   resetMatrixToPhase(taskId, phase) {
     return runSync(this._async.resetMatrixToPhase(taskId, phase));
   }
-  getMessageTranslations(taskId, messageId, locale) {
-    return runSync(
-      this._async.getMessageTranslations(taskId, messageId, locale)
-    );
+  getMessageTranslations(taskId, messageId) {
+    return runSync(this._async.getMessageTranslations(taskId, messageId));
   }
   // ------------------------------------------------------------------
   // Error events
@@ -1321,6 +1485,18 @@ var Orchestrator = class {
   getSlotsStatus() {
     return runSync(this._async.getSlotsStatus());
   }
+  getSubagentsStatus() {
+    return runSync(this._async.getSubagentsStatus());
+  }
+  setSubagentsEnabled(enabled) {
+    return runSync(this._async.setSubagentsEnabled(enabled));
+  }
+  reloadServices() {
+    return runSync(this._async.reloadServices());
+  }
+  getReloadStatus() {
+    return runSync(this._async.getReloadStatus());
+  }
   // ------------------------------------------------------------------
   // Auth / WebSocket status
   // ------------------------------------------------------------------
@@ -1464,9 +1640,15 @@ var RealtimeClient = class {
     this._socket = null;
     this._handlers = /* @__PURE__ */ new Map();
     this._connected = false;
+    // Multi-subscriber room-diffing state (mirrors WebSocketProvider)
+    this._subscriptions = /* @__PURE__ */ new Map();
+    this._currentRooms = /* @__PURE__ */ new Set();
+    this._subIdCounter = 0;
     this._baseUrl = baseUrl.replace(/\/+$/, "");
     this._socketOptions = opts.socketOptions ?? {};
     this._getToken = opts.getToken;
+    this._clientId = opts.clientId ?? "orchestrator-client";
+    this._locale = opts.locale;
     if (opts.autoConnect) {
       this.connect();
     }
@@ -1479,19 +1661,28 @@ var RealtimeClient = class {
     if (this._getToken) {
       auth.token = typeof this._getToken === "function" ? await this._getToken() : this._getToken;
     }
+    const query = { client_id: this._clientId };
+    if (this._locale) {
+      query.locale = this._locale;
+    }
     const { io } = await import("socket.io-client");
     this._socket = io(this._baseUrl, {
       path: "/socket.io",
       auth,
+      query,
       transports: ["websocket", "polling"],
       ...this._socketOptions
     });
     this._socket.on("connect", () => {
       this._connected = true;
+      this._currentRooms = /* @__PURE__ */ new Set();
+      this._syncRooms();
     });
     this._socket.on("disconnect", () => {
       this._connected = false;
+      this._currentRooms = /* @__PURE__ */ new Set();
     });
+    this._socket.on("message", (payload) => this._dispatch(payload));
     return new Promise((resolve, reject) => {
       if (!this._socket) {
         reject(new Error("RealtimeClient not connected"));
@@ -1511,53 +1702,187 @@ var RealtimeClient = class {
     }
     this._connected = false;
   }
+  /**
+   * Dispatch a message envelope to registered handlers and subscribers.
+   * The server sends: socket.emit("message", {type: "message", event: {..., event_type: "...", ...}})
+   */
+  _dispatch(payload) {
+    const envelope = payload;
+    const event = envelope.event ?? envelope;
+    const eventType = event.event_type;
+    if (!eventType) return;
+    const handlers = this._handlers.get(eventType);
+    if (handlers) {
+      for (const h of handlers) {
+        h(event);
+      }
+    }
+    for (const sub of this._subscriptions.values()) {
+      sub.handler(event);
+    }
+  }
   /**
    * Subscribe to realtime events for a specific task.
+   * Emits a `join` event with `{rooms: ["task:{taskId}"]}`.
    */
-  async subscribeTask(taskId) {
+  subscribeTask(taskId) {
     if (!this._socket) throw new Error("RealtimeClient not connected");
-    return new Promise((resolve, reject) => {
-      this._socket?.emit(
-        "subscribe",
-        { task_id: taskId },
-        (response) => {
-          if (response.ok) resolve();
-          else reject(new Error(response.error ?? "Subscription failed"));
-        }
-      );
-    });
+    this._socket.emit("join", { rooms: [`task:${taskId}`] });
   }
   /**
    * Unsubscribe from realtime events for a specific task.
+   * Emits a `leave` event with `{rooms: ["task:{taskId}"]}`.
    */
-  async unsubscribeTask(taskId) {
+  unsubscribeTask(taskId) {
     if (!this._socket) throw new Error("RealtimeClient not connected");
-    return new Promise((resolve, reject) => {
-      this._socket?.emit(
-        "unsubscribe",
-        { task_id: taskId },
-        (response) => {
-          if (response.ok) resolve();
-          else reject(new Error(response.error ?? "Unsubscription failed"));
-        }
-      );
-    });
+    this._socket.emit("leave", { rooms: [`task:${taskId}`] });
+  }
+  /**
+   * Subscribe to event-type-scoped rooms.
+   * e.g. subscribeEvents("task_created", "task_deleted")
+   */
+  subscribeEvents(...eventTypes) {
+    if (!this._socket) throw new Error("RealtimeClient not connected");
+    const rooms = eventTypes.map((t) => `event:${t}`);
+    this._socket.emit("join", { rooms });
+  }
+  /**
+   * Unsubscribe from event-type-scoped rooms.
+   */
+  unsubscribeEvents(...eventTypes) {
+    if (!this._socket) throw new Error("RealtimeClient not connected");
+    const rooms = eventTypes.map((t) => `event:${t}`);
+    this._socket.emit("leave", { rooms });
+  }
+  /**
+   * Subscribe to the `all` broadcast room (receives all events).
+   */
+  subscribeAll() {
+    if (!this._socket) throw new Error("RealtimeClient not connected");
+    this._socket.emit("join", { rooms: ["all"] });
+  }
+  /**
+   * Subscribe to a locale-specific room.
+   */
+  subscribeLocale(locale) {
+    if (!this._socket) throw new Error("RealtimeClient not connected");
+    this._socket.emit("join", { rooms: [`locale:${locale}`] });
+  }
+  /**
+   * Unsubscribe from a locale-specific room.
+   */
+  unsubscribeLocale(locale) {
+    if (!this._socket) throw new Error("RealtimeClient not connected");
+    this._socket.emit("leave", { rooms: [`locale:${locale}`] });
+  }
+  /**
+   * Join arbitrary rooms by name.
+   */
+  joinRooms(rooms) {
+    if (!this._socket) throw new Error("RealtimeClient not connected");
+    this._socket.emit("join", { rooms });
+  }
+  /**
+   * Leave arbitrary rooms by name.
+   */
+  leaveRooms(rooms) {
+    if (!this._socket) throw new Error("RealtimeClient not connected");
+    this._socket.emit("leave", { rooms });
+  }
+  // ------------------------------------------------------------------
+  // Multi-subscriber API (mirrors WebSocketProvider room-diffing)
+  // ------------------------------------------------------------------
+  /**
+   * Register a subscriber that receives all events from the given rooms.
+   *
+   * Room membership is managed automatically: the client joins the union
+   * of all active subscribers' rooms and leaves rooms that are no longer
+   * needed when the last subscriber referencing them is removed.
+   *
+   * The `handler` receives the unwrapped event dict (same object that
+   * `on()` handlers receive).
+   *
+   * Returns an opaque subscription id that must be passed to
+   * `unsubscribe()` to remove the subscription.
+   *
+   * Example — mirror the webui's per-component subscription pattern:
+   *
+   *   const id = rt.subscribe((event) => {
+   *     if (event.event_type === "task_status_changed") { ... }
+   *   }, [`task:${taskId}`]);
+   *
+   *   // later, on cleanup:
+   *   rt.unsubscribe(id);
+   */
+  subscribe(handler, rooms) {
+    const id = `sub_${++this._subIdCounter}`;
+    this._subscriptions.set(id, { handler, rooms });
+    this._syncRooms();
+    return id;
+  }
+  /**
+   * Remove a subscription registered via `subscribe()`.
+   *
+   * Rooms that are no longer referenced by any remaining subscriber are
+   * left automatically.
+   */
+  unsubscribe(id) {
+    this._subscriptions.delete(id);
+    this._syncRooms();
+  }
+  /**
+   * Diff the union of all subscribers' rooms against the currently joined
+   * rooms and emit `join`/`leave` for the delta.  No-ops when not connected.
+   */
+  _syncRooms() {
+    const socket = this._socket;
+    if (!socket?.connected) return;
+    const needed = /* @__PURE__ */ new Set();
+    for (const sub of this._subscriptions.values()) {
+      for (const r of sub.rooms) needed.add(r);
+    }
+    const toJoin = [...needed].filter((r) => !this._currentRooms.has(r));
+    const toLeave = [...this._currentRooms].filter((r) => !needed.has(r));
+    if (toJoin.length) socket.emit("join", { rooms: toJoin });
+    if (toLeave.length) socket.emit("leave", { rooms: toLeave });
+    this._currentRooms = needed;
+  }
+  /**
+   * Send a ping to the server.
+   */
+  ping() {
+    if (!this._socket) throw new Error("RealtimeClient not connected");
+    this._socket.emit("ping");
   }
   /**
    * Register a handler for a specific event type.
+   *
+   * Domain events (task_created, task_status_changed, etc.) are dispatched
+   * via the message envelope. Raw socket events (connect, disconnect,
+   * connection_established, rooms_updated, pong) are wired directly.
    */
   on(event, handler) {
     if (!this._handlers.has(event)) {
       this._handlers.set(event, /* @__PURE__ */ new Set());
       if (this._socket) {
-        this._socket.on(event, (...args) => {
-          const handlers2 = this._handlers.get(event);
-          if (handlers2) {
-            for (const h of handlers2) {
-              h(...args);
+        const rawSocketEvents = /* @__PURE__ */ new Set([
+          "connect",
+          "disconnect",
+          "connect_error",
+          "connection_established",
+          "rooms_updated",
+          "pong"
+        ]);
+        if (rawSocketEvents.has(event)) {
+          this._socket.on(event, (...args) => {
+            const handlers2 = this._handlers.get(event);
+            if (handlers2) {
+              for (const h of handlers2) {
+                h(...args);
+              }
             }
-          }
-        });
+          });
+        }
       }
     }
     const handlers = this._handlers.get(event);