@parall/daemon 1.34.0 → 1.36.0

package/bundle/parall-daemon.js

@@ -27118,6 +27118,7 @@ var ENDPOINTS = {
   // Org-scoped
   ORG: (orgId) => `${API_BASE}/orgs/${orgId}`,
   ORG_MEMBERS: (orgId) => `${API_BASE}/orgs/${orgId}/members`,
+  TEAMS: (orgId) => `${API_BASE}/orgs/${orgId}/teams`,
   ORG_MEMBERS_ONLINE: (orgId) => `${API_BASE}/orgs/${orgId}/members/online`,
   ORG_MEMBER: (orgId, userId) => `${API_BASE}/orgs/${orgId}/members/${userId}`,
   ORG_MEMBER_CHATS: (orgId, memberId) => `${API_BASE}/orgs/${orgId}/members/${memberId}/chats`,
@@ -27162,6 +27163,7 @@ var ENDPOINTS = {
   AGENT: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}`,
   AGENT_API_KEYS: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/api-keys`,
   AGENT_API_KEY: (orgId, agentId, key) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/api-keys/${key}`,
+  AGENT_API_KEY_REGENERATE: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/api-keys/regenerate`,
   AGENT_AVATAR: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/avatar`,
   AGENT_ACTIVITY: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/activity`,
   AGENT_MONITOR: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/monitor`,
@@ -27201,6 +27203,7 @@ var ENDPOINTS = {
   MACHINE_AGENT_WORKSPACE_SETUP: (orgId, machineId, agentId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/agents/${agentId}/workspace/setup`,
   MACHINE_LLM_SOURCE: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/llm-source`,
   MACHINE_PROVIDER_ENABLED: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/provider-enabled`,
+  MACHINE_CAPABILITIES: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/capabilities`,
   MACHINE_RUNTIME_AUTH: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/runtime-auth`,
   MACHINE_KEYS: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/keys`,
   MACHINE_KEY: (orgId, machineId, keyId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/keys/${keyId}`,
@@ -27221,6 +27224,12 @@ var ENDPOINTS = {
   MACHINES_ME_AGENT_WORKSPACE_STATE: (agentId) => `${API_BASE}/machines/me/agents/${agentId}/workspace-state`,
   MACHINES_ME_WS_TICKET: `${API_BASE}/machines/me/ws/ticket`,
   MACHINES_ME_BROWSE_RESPONSE: (requestId) => `${API_BASE}/machines/me/browse-response/${requestId}`,
+  // Hosted browser live-viewer control plane (api-server, NOT clip-service):
+  // the web client drives WebRTC signaling + tab nav through VIEWER_COMMAND;
+  // api-server brokers each command to the host daemon via the machine:{id}
+  // request/reply bridge (mirrors filesystem browse), and the daemon replies on
+  // VIEWER_RESPONSE. See docs/engineering-design/hosted-browser-provider-design.md.
+  MACHINES_ME_BROWSER_PROFILE_VIEWER_RESPONSE: (requestId) => `${API_BASE}/machines/me/browser-profiles/viewer-response/${requestId}`,
   // Tasks (org-scoped)
   TASKS: (orgId) => `${API_BASE}/orgs/${orgId}/tasks`,
   TASK: (orgId, taskId) => `${API_BASE}/orgs/${orgId}/tasks/${taskId}`,
@@ -27247,6 +27256,17 @@ var ENDPOINTS = {
   SCHEDULE_CANCEL: (orgId, id) => `${API_BASE}/orgs/${orgId}/schedules/${id}/cancel`,
   SCHEDULE_RUNS: (orgId, id) => `${API_BASE}/orgs/${orgId}/schedules/${id}/runs`,
   SCHEDULE_RUN: (orgId, runId) => `${API_BASE}/orgs/${orgId}/schedule_runs/${runId}`,
+  // External triggers (org-scoped incoming integration primitive)
+  EXTERNAL_CONNECTIONS: (orgId) => `${API_BASE}/orgs/${orgId}/external-connections`,
+  EXTERNAL_CONNECTION: (orgId, connectionId) => `${API_BASE}/orgs/${orgId}/external-connections/${connectionId}`,
+  EXTERNAL_CONNECTION_INGRESS_TOKEN_REGENERATE: (orgId, connectionId) => `${API_BASE}/orgs/${orgId}/external-connections/${connectionId}/ingress-token/regenerate`,
+  EXTERNAL_TRIGGER_SCHEMA: (orgId, connectionId) => `${API_BASE}/orgs/${orgId}/external-connections/${connectionId}/trigger-schema`,
+  EXTERNAL_INGRESS_EVENTS: (orgId) => `${API_BASE}/orgs/${orgId}/external-ingress-events`,
+  EXTERNAL_INGRESS_EVENT: (orgId, eventId) => `${API_BASE}/orgs/${orgId}/external-ingress-events/${eventId}`,
+  EXTERNAL_TRIGGERS: (orgId) => `${API_BASE}/orgs/${orgId}/external-triggers`,
+  EXTERNAL_TRIGGER: (orgId, triggerId) => `${API_BASE}/orgs/${orgId}/external-triggers/${triggerId}`,
+  EXTERNAL_TRIGGER_RUNS: (orgId) => `${API_BASE}/orgs/${orgId}/external-trigger-runs`,
+  EXTERNAL_TRIGGER_RUN: (orgId, runId) => `${API_BASE}/orgs/${orgId}/external-trigger-runs/${runId}`,
   // Invitations (org-scoped, admin)
   ORG_INVITATIONS: (orgId) => `${API_BASE}/orgs/${orgId}/invitations`,
   ORG_INVITATION: (orgId, invId) => `${API_BASE}/orgs/${orgId}/invitations/${invId}`,
@@ -27286,6 +27306,9 @@ var ENDPOINTS = {
   // Wiki Path Scopes (AFCS ACL)
   WIKI_PATH_SCOPES: (orgId, wikiId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/path-scopes`,
   WIKI_PATH_SCOPE: (orgId, wikiId, scopeId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/path-scopes/${scopeId}`,
+  // Wiki Path Restrictions (AFCS narrowing ACL — private subtrees)
+  WIKI_RESTRICTIONS: (orgId, wikiId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/restrictions`,
+  WIKI_RESTRICTION: (orgId, wikiId, restrictionId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/restrictions/${restrictionId}`,
   WIKI_ACCESS_STATUS: (orgId, wikiId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/access-status`,
   WIKI_ACCESS_REQUESTS: (orgId, wikiId) => `${WIKI_BASE}/orgs/${orgId}/wikis/${wikiId}/access-requests`,
   // Wiki History (commits, file commits, blame)
@@ -27351,6 +27374,7 @@ var ENDPOINTS = {
   // Clips (org-scoped, served by clip-service)
   CLIPS: (orgId) => `${CLIP_BASE}/orgs/${orgId}/clips`,
   CLIP: (orgId, clipId) => `${CLIP_BASE}/orgs/${orgId}/clips/${clipId}`,
+  CLIPS_BULK_METADATA: (orgId) => `${CLIP_BASE}/orgs/${orgId}/clips/bulk-metadata`,
   CLIP_AGENTS: (orgId, clipId) => `${CLIP_BASE}/orgs/${orgId}/clips/${clipId}/agents`,
   AGENT_CLIPS: (orgId, agentId) => `${CLIP_BASE}/orgs/${orgId}/agents/${agentId}/clips`,
   AGENT_CLIP: (orgId, agentId, clipId) => `${CLIP_BASE}/orgs/${orgId}/agents/${agentId}/clips/${clipId}`,
@@ -27363,6 +27387,9 @@ var ENDPOINTS = {
   BROWSER_PROFILE_RESET: (orgId, profileId) => `${CLIP_BASE}/orgs/${orgId}/browser-profiles/${profileId}/reset`,
   BROWSER_PROFILE_CONSENTS: (orgId, profileId) => `${CLIP_BASE}/orgs/${orgId}/browser-profiles/${profileId}/consents`,
   BROWSER_PROFILE_CONSENT: (orgId, profileId, clipId) => `${CLIP_BASE}/orgs/${orgId}/browser-profiles/${profileId}/consents/${clipId}`,
+  // Live viewer command — on api-server (API_BASE), not clip-service: it rides
+  // the machine control-plane request/reply bridge that lives in api-server.
+  BROWSER_PROFILE_VIEWER_COMMAND: (orgId, profileId) => `${API_BASE}/orgs/${orgId}/browser-profiles/${profileId}/viewer/command`,
   // Clip registry (global, served by clip-service → Pinix Hub proxy)
   CLIP_REGISTRY: () => `${CLIP_BASE}/registry/clips`
 };
@@ -27439,6 +27466,7 @@ var WS_EVENTS = {
   MACHINE_CONFIG_UPDATED: "machine.config.updated",
   MACHINE_CLIP_SYNC: "machine.clip.sync",
   MACHINE_BROWSER_PROFILE_LIFECYCLE: "machine.browser_profile.lifecycle",
+  MACHINE_BROWSER_PROFILE_VIEWER: "machine.browser_profile.viewer",
   AGENT_NEW_SESSION: "agent.new_session",
   CLIP_CREATED: "clip.created",
   CLIP_REMOVED: "clip.removed",
@@ -27448,6 +27476,7 @@ var WS_EVENTS = {
 // ts/sdk/dist/client.js
 var ParallClient = class _ParallClient {
   baseUrl;
+  wikiBaseUrl;
   token;
   onTokenExpired;
   getRefreshToken;
@@ -27499,12 +27528,22 @@ var ParallClient = class _ParallClient {
   }
   constructor(options = {}) {
     this.baseUrl = options.baseUrl ?? "";
+    this.wikiBaseUrl = options.wikiBaseUrl ?? this.baseUrl;
     this.token = options.token ?? null;
     this.onTokenExpired = options.onTokenExpired;
     this.getRefreshToken = options.getRefreshToken;
     this.setTokens = options.setTokens;
     this.swimlaneName = options.swimlaneName;
   }
+  /**
+   * Pick the origin for a request path: wiki-service base for `/wiki/v1`
+   * endpoints, api base for everything else. The path itself (from ENDPOINTS)
+   * is authoritative, so wiki vs api routing can't drift from how a caller
+   * happens to invoke the client.
+   */
+  baseUrlFor(path15) {
+    return path15.startsWith(WIKI_BASE) ? this.wikiBaseUrl : this.baseUrl;
+  }
   setToken(token) {
     this.token = token;
   }
@@ -27569,7 +27608,7 @@ var ParallClient = class _ParallClient {
     if (!retried) {
       await this.ensureFreshToken(path15);
     }
-    let url = `${this.baseUrl}${path15}`;
+    let url = `${this.baseUrlFor(path15)}${path15}`;
     if (query) {
       const params = new URLSearchParams();
       for (const [key, value] of Object.entries(query)) {
@@ -27590,7 +27629,10 @@ var ParallClient = class _ParallClient {
         method,
         headers,
         body: body ? JSON.stringify(body) : void 0,
-        signal
+        signal,
+        // keepalive lets a request fired during page unload (e.g. the browser
+        // viewer's stream.close on pagehide) outlive the document.
+        keepalive: opts?.keepalive
       });
     } catch (err) {
       throw _ParallClient.normalizeFetchError(err);
@@ -27638,7 +27680,7 @@ var ParallClient = class _ParallClient {
     void _drop;
     let res;
     try {
-      res = await fetch(`${this.baseUrl}${path15}`, {
+      res = await fetch(`${this.baseUrlFor(path15)}${path15}`, {
         method,
         headers,
         body,
@@ -27761,6 +27803,10 @@ var ParallClient = class _ParallClient {
     const res = await this.request("GET", ENDPOINTS.ORG_MEMBERS(orgId));
     return res.data;
   }
+  async getTeams(orgId) {
+    const res = await this.request("GET", ENDPOINTS.TEAMS(orgId));
+    return res.data;
+  }
   async getOnlineMembers(orgId) {
     const res = await this.request("GET", ENDPOINTS.ORG_MEMBERS_ONLINE(orgId));
     return res.user_ids ?? [];
@@ -27794,6 +27840,21 @@ var ParallClient = class _ParallClient {
       q.limit = String(params.limit);
     return this.request("GET", ENDPOINTS.ORG_MEMBER_TASKS(orgId, memberId), void 0, q);
   }
+  // Auto-paginated variant of getMemberTasks: fetches ALL pending tasks
+  // (todo + in_progress) assigned to a member, including subtasks (the
+  // endpoint does not filter parent_id). Powers the CLI `tasks assigned`
+  // command so an agent answering "what's on X's plate" sees the full
+  // backlog, not just the first page.
+  async getMemberTasksAll(orgId, memberId) {
+    const all = [];
+    let cursor;
+    do {
+      const res = await this.getMemberTasks(orgId, memberId, { cursor, limit: 100 });
+      all.push(...res.data);
+      cursor = res.has_more ? res.next_cursor : void 0;
+    } while (cursor);
+    return all;
+  }
   // ---- Invitations ----
   async createInvitation(orgId, email, role) {
     return this.request("POST", ENDPOINTS.ORG_INVITATIONS(orgId), { email, role });
@@ -27999,6 +28060,10 @@ var ParallClient = class _ParallClient {
   async createAgentApiKey(orgId, agentId) {
     return this.request("POST", ENDPOINTS.AGENT_API_KEYS(orgId, agentId));
   }
+  /** Revokes all of the agent's active API keys and mints a replacement. */
+  async regenerateAgentApiKey(orgId, agentId) {
+    return this.request("POST", ENDPOINTS.AGENT_API_KEY_REGENERATE(orgId, agentId));
+  }
   async revokeAgentApiKey(orgId, agentId, key) {
     return this.request("DELETE", ENDPOINTS.AGENT_API_KEY(orgId, agentId, key));
   }
@@ -28170,6 +28235,17 @@ var ParallClient = class _ParallClient {
       provider_enabled: providerEnabled
     });
   }
+  /**
+   * Replace the machine's capability set (admin). Primary use: healing a
+   * machine that registered without `browser_provider` during the capability
+   * migration's rolling-deploy window. Removing `agent_host` is rejected by the
+   * server while agents are attached (409 AGENTS_STILL_ATTACHED).
+   */
+  async patchMachineCapabilities(orgId, machineId, capabilities) {
+    return this.request("PATCH", ENDPOINTS.MACHINE_CAPABILITIES(orgId, machineId), {
+      capabilities
+    });
+  }
   /** Get machine-level runtime auth state. */
   async getMachineRuntimeAuth(orgId, machineId) {
     return this.request("GET", ENDPOINTS.MACHINE_RUNTIME_AUTH(orgId, machineId));
@@ -28260,6 +28336,22 @@ var ParallClient = class _ParallClient {
   async postBrowseResponse(requestId, response) {
     return this.request("POST", ENDPOINTS.MACHINES_ME_BROWSE_RESPONSE(requestId), response);
   }
+  /**
+   * `POST /machines/me/browser-profiles/viewer-response/{requestId}` — daemon
+   * reply to a `machine.browser_profile.viewer` control command. Wakes the
+   * api-server request/reply bridge (mirrors {@link postBrowseResponse}).
+   */
+  async postBrowserProfileViewerResponse(requestId, response) {
+    return this.request("POST", ENDPOINTS.MACHINES_ME_BROWSER_PROFILE_VIEWER_RESPONSE(requestId), response);
+  }
+  /**
+   * `POST /orgs/{orgId}/browser-profiles/{profileId}/viewer/command` — drive the
+   * hosted browser live viewer (WebRTC signaling + tab nav). Authz: profile
+   * owner or org admin. api-server brokers the command to the host daemon.
+   */
+  async browserViewerCommand(orgId, profileId, req, opts) {
+    return this.request("POST", ENDPOINTS.BROWSER_PROFILE_VIEWER_COMMAND(orgId, profileId), req, void 0, false, opts);
+  }
   async resizeMachine(orgId, machineId, spec) {
     return this.request("PATCH", ENDPOINTS.MACHINE_SPEC(orgId, machineId), spec);
   }
@@ -28352,7 +28444,7 @@ var ParallClient = class _ParallClient {
    * Returns null when the server responds with 304 (config unchanged).
    */
   async getPlatformConfig(currentVersion) {
-    const url = `${this.baseUrl}${ENDPOINTS.PLATFORM_CONFIG}`;
+    const url = `${this.baseUrlFor(ENDPOINTS.PLATFORM_CONFIG)}${ENDPOINTS.PLATFORM_CONFIG}`;
     const extra = {};
     if (currentVersion !== void 0) {
       extra["If-None-Match"] = currentVersion;
@@ -28518,6 +28610,55 @@ var ParallClient = class _ParallClient {
   async getScheduleRun(orgId, runId) {
     return this.request("GET", ENDPOINTS.SCHEDULE_RUN(orgId, runId));
   }
+  // ---- External triggers (org-scoped) ----
+  async createExternalConnection(orgId, input) {
+    return this.request("POST", ENDPOINTS.EXTERNAL_CONNECTIONS(orgId), input);
+  }
+  async listExternalConnections(orgId, filters) {
+    return this.request("GET", ENDPOINTS.EXTERNAL_CONNECTIONS(orgId), void 0, filters);
+  }
+  async getExternalConnection(orgId, connectionId) {
+    return this.request("GET", ENDPOINTS.EXTERNAL_CONNECTION(orgId, connectionId));
+  }
+  async updateExternalConnection(orgId, connectionId, patch) {
+    return this.request("PATCH", ENDPOINTS.EXTERNAL_CONNECTION(orgId, connectionId), patch);
+  }
+  async regenerateExternalConnectionIngressToken(orgId, connectionId) {
+    return this.request("POST", ENDPOINTS.EXTERNAL_CONNECTION_INGRESS_TOKEN_REGENERATE(orgId, connectionId));
+  }
+  async deleteExternalConnection(orgId, connectionId) {
+    return this.request("DELETE", ENDPOINTS.EXTERNAL_CONNECTION(orgId, connectionId));
+  }
+  async getExternalTriggerSchema(orgId, connectionId) {
+    return this.request("GET", ENDPOINTS.EXTERNAL_TRIGGER_SCHEMA(orgId, connectionId));
+  }
+  async listExternalIngressEvents(orgId, filters) {
+    return this.request("GET", ENDPOINTS.EXTERNAL_INGRESS_EVENTS(orgId), void 0, filters);
+  }
+  async getExternalIngressEvent(orgId, eventId) {
+    return this.request("GET", ENDPOINTS.EXTERNAL_INGRESS_EVENT(orgId, eventId));
+  }
+  async createExternalTrigger(orgId, input) {
+    return this.request("POST", ENDPOINTS.EXTERNAL_TRIGGERS(orgId), input);
+  }
+  async listExternalTriggers(orgId, filters) {
+    return this.request("GET", ENDPOINTS.EXTERNAL_TRIGGERS(orgId), void 0, filters);
+  }
+  async getExternalTrigger(orgId, triggerId) {
+    return this.request("GET", ENDPOINTS.EXTERNAL_TRIGGER(orgId, triggerId));
+  }
+  async updateExternalTrigger(orgId, triggerId, patch) {
+    return this.request("PATCH", ENDPOINTS.EXTERNAL_TRIGGER(orgId, triggerId), patch);
+  }
+  async deleteExternalTrigger(orgId, triggerId) {
+    return this.request("DELETE", ENDPOINTS.EXTERNAL_TRIGGER(orgId, triggerId));
+  }
+  async listExternalTriggerRuns(orgId, filters) {
+    return this.request("GET", ENDPOINTS.EXTERNAL_TRIGGER_RUNS(orgId), void 0, filters);
+  }
+  async getExternalTriggerRun(orgId, runId) {
+    return this.request("GET", ENDPOINTS.EXTERNAL_TRIGGER_RUN(orgId, runId));
+  }
   // ---- Wikis (org-scoped) ----
   async createWiki(orgId, data) {
     return this.request("POST", ENDPOINTS.WIKIS(orgId), data);
@@ -28532,8 +28673,35 @@ var ParallClient = class _ParallClient {
   async getWikiTree(orgId, wikiId, params) {
     return this.request("GET", ENDPOINTS.WIKI_TREE(orgId, wikiId), void 0, params);
   }
+  /**
+   * Resolve a server-returned, host-relative media URL (a wiki `signed_url`
+   * like `/wiki/v1/signed/files?token=...`) against this client's base origin,
+   * so it can be dropped straight into a browser `<img>`/`<video>`/`<iframe>`
+   * `src`.
+   *
+   * wiki-service returns these relative on purpose — it doesn't know its own
+   * public origin. A relative `src` resolves against the *page* origin, which
+   * only works when the page and wiki-service share an origin (local dev:
+   * same-origin + Next.js `/wiki/*` proxy). In deployed envs the app
+   * (app.parall.com) and wiki-service (api.parall.com) are different origins,
+   * so `app.parall.com/wiki/v1/signed/files` hits the SPA's own `/wiki/[...]`
+   * catch-all route — an `<iframe>` then recursively renders the whole app
+   * instead of the file. Prefixing with the wiki base (the exact origin every
+   * wiki API request already uses — `baseUrlFor` resolves `/wiki/v1` paths to
+   * `wikiBaseUrl`) makes the URL absolute against the origin that actually
+   * serves the bytes. An empty base (local dev, same-origin proxy) leaves it
+   * relative, preserving the proxy path.
+   */
+  absoluteMediaUrl(url) {
+    if (/^https?:\/\//i.test(url))
+      return url;
+    return `${this.baseUrlFor(url)}${url}`;
+  }
   async getWikiBlob(orgId, wikiId, params) {
-    return this.request("GET", ENDPOINTS.WIKI_BLOB(orgId, wikiId), void 0, params);
+    const blob = await this.request("GET", ENDPOINTS.WIKI_BLOB(orgId, wikiId), void 0, params);
+    if (blob.signed_url)
+      blob.signed_url = this.absoluteMediaUrl(blob.signed_url);
+    return blob;
   }
   async getWikiNodeSections(orgId, wikiId, params) {
     return this.request("GET", ENDPOINTS.WIKI_NODE_SECTIONS(orgId, wikiId), void 0, params);
@@ -28623,7 +28791,10 @@ var ParallClient = class _ParallClient {
    * token — don't leak it.
    */
   async getWikiFilePreviewUrl(orgId, wikiId, params) {
-    return this.request("POST", ENDPOINTS.WIKI_FILE_PREVIEW_URL(orgId, wikiId), params);
+    const res = await this.request("POST", ENDPOINTS.WIKI_FILE_PREVIEW_URL(orgId, wikiId), params);
+    if (res.url)
+      res.url = this.absoluteMediaUrl(res.url);
+    return res;
   }
   // ---- Wiki Path Scopes (AFCS ACL) ----
   async getWikiPathScopes(orgId, wikiId) {
@@ -28636,6 +28807,17 @@ var ParallClient = class _ParallClient {
   async deleteWikiPathScope(orgId, wikiId, scopeId) {
     await this.request("DELETE", ENDPOINTS.WIKI_PATH_SCOPE(orgId, wikiId, scopeId));
   }
+  // ---- Wiki Path Restrictions (narrowing ACL — private subtrees) ----
+  async getWikiRestrictions(orgId, wikiId) {
+    const res = await this.request("GET", ENDPOINTS.WIKI_RESTRICTIONS(orgId, wikiId));
+    return res.data;
+  }
+  async createWikiRestriction(orgId, wikiId, data) {
+    return this.request("POST", ENDPOINTS.WIKI_RESTRICTIONS(orgId, wikiId), data);
+  }
+  async deleteWikiRestriction(orgId, wikiId, restrictionId) {
+    await this.request("DELETE", ENDPOINTS.WIKI_RESTRICTION(orgId, wikiId, restrictionId));
+  }
   async getWikiAccessStatus(orgId, wikiId, path15) {
     return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path15 ? { path: path15 } : void 0);
   }
@@ -28798,6 +28980,10 @@ var ParallClient = class _ParallClient {
   async updateClip(orgId, clipId, req) {
     return this.request("PATCH", ENDPOINTS.CLIP(orgId, clipId), req);
   }
+  /** Atomically set display_name and/or description on multiple clip instances (application metadata). */
+  async bulkUpdateClipMetadata(orgId, req) {
+    return this.request("POST", ENDPOINTS.CLIPS_BULK_METADATA(orgId), req);
+  }
   async deleteClip(orgId, clipId) {
     await this.request("DELETE", ENDPOINTS.CLIP(orgId, clipId));
   }
@@ -28824,6 +29010,9 @@ var ParallClient = class _ParallClient {
     const resp = await this.request("GET", ENDPOINTS.CLIP_ONLINE(orgId));
     return resp.data;
   }
+  /** Org-wide browser-profile discovery list. Returns the sanitized
+   *  {@link BrowserProfileListItem} shape (not the full domain model), each row
+   *  carrying a per-viewer `can_open` control hint. */
   async listBrowserProfiles(orgId) {
     const resp = await this.request("GET", ENDPOINTS.BROWSER_PROFILES(orgId));
     return resp.data;
@@ -29698,7 +29887,7 @@ async function runCLI(args) {
 init_config();
 
 // ts/daemon/dist/supervisor.js
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 import * as fs12 from "node:fs";
 import * as path13 from "node:path";
 
@@ -31622,6 +31811,10 @@ function encodeEnvelope2(msg) {
   header.writeUInt32BE(json.length, 1);
   return Buffer.concat([header, json]);
 }
+function registrationKey(clips) {
+  const sorted = [...clips].sort((a, b) => (a.alias ?? "").localeCompare(b.alias ?? ""));
+  return JSON.stringify(sorted);
+}
 var EnvelopeDecoder2 = class _EnvelopeDecoder {
   buf = Buffer.alloc(0);
   push(chunk) {
@@ -31657,7 +31850,15 @@ var ClipProvider = class _ClipProvider {
   heartbeatTimer = null;
   statusUnsubscribe = null;
   manifestUnsubscribe = null;
+  // Set when the clip manifest/set changed and the hub's copy is stale. Drained
+  // by flushReregister(), which re-registers IN-STREAM (no reconnect).
   needsReregister = false;
+  // Canonical key of the clip-registration set last sent to the hub on the
+  // CURRENT stream. flushReregister diff-gates against it so a cold-start that
+  // re-derives an identical set (the common case — a clip's command surface is
+  // stable across spawns) does not emit a redundant re-register. Reset per
+  // stream; the first-frame register in openStream re-seeds it.
+  lastRegisteredKey = null;
   // Monotonic stream id, bumped by openStream(). Handlers from a stream that a
   // newer openStream() has superseded bail in handleDisconnect(gen), so their
   // late close/end/error can't reconnect against the healthy replacement.
@@ -31698,6 +31899,7 @@ var ClipProvider = class _ClipProvider {
     if (this.stopped)
       return;
     const gen = ++this.streamGeneration;
+    this.lastRegisteredKey = null;
     try {
       this.closeStream();
       this.closeSession();
@@ -31796,21 +31998,57 @@ var ClipProvider = class _ClipProvider {
   startHeartbeat() {
     this.clearHeartbeatTimer();
     this.heartbeatTimer = setInterval(() => {
-      if (this.needsReregister) {
-        this.needsReregister = false;
-        this.opts.log.info("[clip-provider] manifest updated \u2014 reconnecting to re-register clips");
-        this.connected = false;
-        this.clearHeartbeatTimer();
-        this.clearReconnectTimer();
-        void this.openStream();
-        return;
-      }
+      this.flushReregister();
       this.sendProviderMessage({ ping: { sentAtUnixMs: Date.now() } }).catch((err) => {
         this.opts.log.warn(`[clip-provider] heartbeat send failed: ${String(err)}`);
       });
     }, _ClipProvider.HEARTBEAT_INTERVAL_MS);
     this.heartbeatTimer.unref?.();
   }
+  /**
+   * Re-register the current clip set on the OPEN stream — the daemon's response
+   * to a manifest/clip-set change. The hub overwrites its stored set from this
+   * full register (clip-provider-sharing-design §11), so a clip install / wake /
+   * sleep no longer requires tearing down and reopening the ProviderStream,
+   * which used to drop any invoke in flight on that stream (in-flight requests
+   * are keyed by request_id on the hub and survive a clip-set swap).
+   *
+   * No-op when the stream is not currently writable; needsReregister stays set
+   * so the next heartbeat tick (or the post-connect flush) retries.
+   *
+   * Against an older hub that still rejects an in-stream duplicate register, the
+   * write reaches a stream the hub then resets; the resulting stream error runs
+   * the normal reconnect path, which re-registers as the first frame — i.e. it
+   * degrades to the previous reconnect-to-re-register behavior, so no capability
+   * negotiation is needed (deploy the hub first).
+   */
+  flushReregister() {
+    if (!this.needsReregister)
+      return;
+    if (!this.connected || !this.stream || this.stream.closed || this.stream.destroyed)
+      return;
+    const clips = this.buildClipRegistrations();
+    if (registrationKey(clips) === this.lastRegisteredKey) {
+      this.needsReregister = false;
+      return;
+    }
+    this.needsReregister = false;
+    this.opts.log.info("[clip-provider] re-registering clips in-stream");
+    this.sendRegister(clips).catch((err) => {
+      this.opts.log.warn(`[clip-provider] in-stream re-register failed: ${String(err)}`);
+      this.needsReregister = true;
+    });
+  }
+  /**
+   * Re-register the current clip set on the open stream — public entry for the
+   * supervisor when machine clip assignments change. Same in-stream path as a
+   * manifest update (no reconnect, in-flight invokes survive). Safe when
+   * disconnected: the flag is flushed on the next heartbeat / post-connect.
+   */
+  reregister() {
+    this.needsReregister = true;
+    this.flushReregister();
+  }
   closeStream() {
     if (this.stream) {
       try {
@@ -31845,7 +32083,7 @@ var ClipProvider = class _ClipProvider {
       });
     });
     this.manifestUnsubscribe = mgr.addManifestListener(() => {
-      this.needsReregister = true;
+      this.reregister();
     });
   }
   unsubscribeStatusChanges() {
@@ -31862,6 +32100,8 @@ var ClipProvider = class _ClipProvider {
       this.handleRegistered(msg.registerResponse);
     } else if (msg.invokeCommand) {
       void this.handleInvokeCommand(msg.invokeCommand);
+    } else if (msg.viewerCommand) {
+      void this.handleViewerCommand(msg.viewerCommand);
     } else if (msg.pong !== void 0) {
     }
   }
@@ -31871,6 +32111,7 @@ var ClipProvider = class _ClipProvider {
       this.connected = true;
       this.reconnectAttempt = 0;
       this.startHeartbeat();
+      this.flushReregister();
     } else {
       this.opts.log.error(`[clip-provider] registration rejected: ${reg.message}`);
       this.stopped = true;
@@ -31924,17 +32165,64 @@ var ClipProvider = class _ClipProvider {
       });
     }
   }
+  /**
+   * Handle a hosted-browser live-viewer command relayed by clip-service over the
+   * stream and reply on the same stream (design §3.4). Always answers the
+   * request/reply bridge exactly once — `{result}` on success, `{error:{message}}`
+   * on failure — and never throws into the message loop, mirroring the BYOC
+   * daemon's handleBrowserProfileViewer (which replies over HTTP instead).
+   */
+  async handleViewerCommand(cmd) {
+    const { requestId } = cmd;
+    if (!this.opts.onViewerCommand) {
+      await this.sendViewerReply(requestId, {
+        error: { message: "live viewer is not supported by this provider" }
+      }).catch(() => {
+      });
+      return;
+    }
+    try {
+      let input;
+      if (cmd.input) {
+        const decoded = Buffer.from(cmd.input, "base64").toString("utf-8");
+        try {
+          input = JSON.parse(decoded);
+        } catch {
+          input = void 0;
+        }
+      }
+      const result = await this.opts.onViewerCommand({
+        profileId: cmd.profileId,
+        sessionId: cmd.sessionId,
+        command: cmd.command,
+        input,
+        turn: cmd.turn
+      });
+      await this.sendViewerReply(requestId, { result });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.opts.log.warn(`[clip-provider] viewer command failed (profile=${cmd.profileId}, command=${cmd.command}): ${message}`);
+      await this.sendViewerReply(requestId, { error: { message } }).catch(() => {
+      });
+    }
+  }
+  /** Send a hosted-viewer reply (base64-encoded JSON body) on the stream. */
+  async sendViewerReply(requestId, reply) {
+    const payload = Buffer.from(JSON.stringify(reply), "utf-8").toString("base64");
+    await this.sendProviderMessage({ viewerResult: { requestId, payload } });
+  }
   // ---------------------------------------------------------------------------
   // Sending
   // ---------------------------------------------------------------------------
-  async sendRegister() {
-    const clips = this.buildClipRegistrations();
+  async sendRegister(prebuilt) {
+    const clips = prebuilt ?? this.buildClipRegistrations();
     await this.sendProviderMessage({
       register: {
         providerName: this.opts.providerName,
         clips
       }
     });
+    this.lastRegisteredKey = registrationKey(clips);
   }
   async sendProviderMessage(msg) {
     if (!this.stream || this.stream.closed || this.stream.destroyed) {
@@ -32001,13 +32289,619 @@ var ClipProvider = class _ClipProvider {
 };
 
 // ts/daemon/dist/clip-runtime/browser-profile-manager.js
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync7 } from "node:fs";
 import { createRequire } from "node:module";
-import * as net from "node:net";
 import * as path9 from "node:path";
 import { fileURLToPath } from "node:url";
+
+// ts/daemon/dist/clip-runtime/browser-viewer-streamer.js
+import { spawn as spawn3 } from "node:child_process";
+
+// ts/daemon/dist/clip-runtime/subprocess.js
+import * as net from "node:net";
+function formatErrorForLog(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return message.replace(/\s+/g, " ").slice(0, 300);
+}
+async function findFreePort() {
+  return new Promise((resolve8, reject) => {
+    const server = net.createServer();
+    server.unref();
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      server.close(() => {
+        if (address && typeof address === "object") {
+          resolve8(address.port);
+        } else {
+          reject(new Error("failed to allocate free port"));
+        }
+      });
+    });
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
+}
+
+// ts/daemon/dist/clip-runtime/browser-viewer-streamer.js
+var BB_VIEWER_HEALTH_TIMEOUT_MS = 1e4;
+var BB_VIEWER_COMMAND_TIMEOUT_MS = 15e3;
+var BB_VIEWER_UNANSWERED_REAP_MS = 9e4;
+var BB_VIEWER_TERM_GRACE_MS = 5e3;
+function isLoopbackBindHost(host) {
+  return host === "127.0.0.1" || host === "localhost" || host === "::1" || host === "[::1]";
+}
+function kickHitsCurrentSession(requested, currentSessionId) {
+  if (currentSessionId === void 0)
+    return false;
+  return requested === void 0 || requested === currentSessionId;
+}
+var BrowserViewerStreamer = class {
+  host;
+  // Live bb-viewer (WebRTC streamer) subprocess per profile. One per profile;
+  // see StreamerState. Cleaned up on stream.close, stopProfile, resetProfile,
+  // and stop().
+  streamers = /* @__PURE__ */ new Map();
+  // The most-recently server-side-kicked viewer session per profile (design §3.6
+  // PR7). After a kick the streamer is gone, so the session-staleness guards
+  // (which key off a live streamer) can no longer reject the kicked viewer's
+  // straggler nav commands — this map does. Reset whenever the profile's streamer
+  // is (re)killed via killProfileStreamer, so a fresh stream.start clears it. One
+  // entry per profile (overwritten per kick); bounded, no leak.
+  kickedSessions = /* @__PURE__ */ new Map();
+  // Set by shutdown(): an in-flight spawnStreamer has no map entry yet, so a
+  // shutdown during its health poll would otherwise let the bb-viewer child
+  // survive daemon stop (on BYOC nothing else reaps it).
+  stopping = false;
+  constructor(host) {
+    this.host = host;
+  }
+  /**
+   * Handle a viewer control command for a profile. Throws on any failure (the
+   * supervisor maps a throw to a `{error:{message}}` reply); never returns a
+   * partial result. `data.input` / `data.turn` / `data.session_id` come from
+   * MachineBrowserProfileViewerData.
+   */
+  async handleViewerCommand(profileId, sessionId, command, input, turn) {
+    if (!profileId)
+      throw new Error("browser profile id is required");
+    if (command !== "stream.start" && sessionId && this.kickedSessions.get(profileId) === sessionId) {
+      throw new Error("viewer session was terminated");
+    }
+    switch (command) {
+      case "stream.start":
+        return this.viewerStreamStart(profileId, sessionId, turn);
+      case "stream.answer":
+        return this.viewerStreamAnswer(profileId, sessionId, input);
+      case "stream.close":
+        return this.viewerStreamClose(profileId, sessionId, input);
+      case "stream.switch":
+        return this.viewerStreamSwitch(profileId, sessionId, input);
+      case "kick":
+        return this.viewerKick(profileId, sessionId, input);
+      case "close":
+        return this.viewerCloseTab(profileId, sessionId, input);
+      case "tab_list":
+      case "tab_new":
+      case "open":
+      case "reload":
+      case "back":
+      case "forward":
+        return this.viewerForwardNav(profileId, sessionId, command, input);
+      default:
+        throw new Error(`unknown viewer command: ${command}`);
+    }
+  }
+  /**
+   * kick — server-side per-viewer disconnect (design §3.6 PR7). Terminates ONE
+   * viewer's WebRTC session: stop its bb-viewer streamer (killing the process
+   * tears down the peer connection + datachannel) and reject the kicked session's
+   * subsequent commands — while bb-browser + Chromium (the agent's live browser)
+   * keep running. This is explicitly DISTINCT from stopping the pod / profile,
+   * which would kill the agent's browser too; a viewer session is a sub-session of
+   * the profile lease, so a kick does NOT release the lease.
+   *
+   * Targets `input.session_id` if given, else the current streamer's session.
+   * Idempotent: kicking with no live streamer still records the kicked session.
+   */
+  viewerKick(profileId, sessionId, input) {
+    const streamer = this.streamers.get(profileId);
+    const requested = typeof input?.session_id === "string" ? input.session_id : void 0;
+    const target = requested || streamer?.sessionId || sessionId;
+    const killsCurrent = kickHitsCurrentSession(requested, streamer?.sessionId);
+    if (killsCurrent) {
+      this.killProfileStreamer(profileId);
+    }
+    if (target)
+      this.kickedSessions.set(profileId, target);
+    this.host.log.info(`[bb-viewer] kicked viewer session ${target || "(none)"} for profile ${profileId}; pod + agent browser keep running`);
+    return target ? { ok: true, kicked: true, session_id: target } : { ok: true, kicked: true };
+  }
+  /**
+   * stream.start — spawn a FRESH bb-viewer for this profile (killing any prior
+   * one), resolve the profile's account-scoped page-target CDP ws URL, and run
+   * the streamer's `connect` command. Records sessionId on the streamer entry.
+   */
+  async viewerStreamStart(profileId, sessionId, turn) {
+    this.killProfileStreamer(profileId);
+    const cdpUrl = await this.host.withDaemonRecovery(() => this.resolveAccountPageCdpUrl(profileId), `viewer stream.start ${profileId}`);
+    await this.bringTargetToFront(cdpUrl);
+    const streamer = await this.spawnStreamer(profileId, sessionId, turn);
+    try {
+      const result = await this.streamerCommand(streamer, "connect", { cdpUrl });
+      streamer.streamedTabId = targetIdFromCdpUrl(cdpUrl);
+      const reapTimer = setTimeout(() => {
+        const current = this.streamers.get(profileId);
+        if (current === streamer && !current.answered) {
+          this.host.log.warn(`[bb-viewer] no stream.answer for ${profileId} within ${BB_VIEWER_UNANSWERED_REAP_MS / 1e3}s; reaping abandoned streamer`);
+          this.killProfileStreamer(profileId);
+        }
+      }, BB_VIEWER_UNANSWERED_REAP_MS);
+      reapTimer.unref?.();
+      return { ...result, streamed_tab_id: streamer.streamedTabId };
+    } catch (err) {
+      this.killProfileStreamer(profileId);
+      throw err;
+    }
+  }
+  /**
+   * stream.answer — apply the client's WebRTC answer to the profile's streamer.
+   * Rejects if the streamer's sessionId no longer matches (a stale viewer
+   * session from a superseded stream.start).
+   */
+  async viewerStreamAnswer(profileId, sessionId, input) {
+    const streamer = this.streamers.get(profileId);
+    if (!streamer)
+      throw new Error("no active viewer streamer for profile");
+    if (streamer.sessionId !== sessionId)
+      throw new Error("stale viewer session");
+    streamer.answered = true;
+    return this.streamerCommand(streamer, "answer", input ?? {});
+  }
+  /**
+   * stream.close — best-effort stop the streamer, then kill + remove it. A
+   * stale session's close (independent HTTP legs can arrive out of order after
+   * a retry) must NOT tear down a successor session's live streamer, so a
+   * mismatched sessionId is ignored. An EMPTY sessionId gets the same stale
+   * treatment — a client closed mid-handshake never received a session id, and
+   * its unscoped close racing the next session's stream.start would kill that
+   * session's live streamer (React StrictMode's dev double-mount exercises
+   * exactly this ordering). The only unscoped close is an explicit
+   * `{force:true}` input, reserved for a server-initiated admin disconnect.
+   */
+  async viewerStreamClose(profileId, sessionId, input) {
+    const streamer = this.streamers.get(profileId);
+    if (streamer) {
+      const force = input?.force === true;
+      if (!force && streamer.sessionId !== sessionId) {
+        return { ok: true, stale: true };
+      }
+      try {
+        await this.streamerCommand(streamer, "stop", {});
+      } catch (err) {
+        this.host.log.warn(`[bb-viewer] stop command failed for ${profileId} (killing anyway): ${formatErrorForLog(err)}`);
+      }
+      this.killProfileStreamer(profileId);
+    }
+    return { ok: true };
+  }
+  /**
+   * stream.switch — point the existing streamer at a different account-scoped
+   * tab. input {tab} is the bb-browser short tab id / target id. Guarded by
+   * sessionId like stream.answer: a superseded session must not steer the
+   * current streamer, and an EMPTY sessionId is rejected the same way — every
+   * real caller has its session id by the time it can switch (it arrives with
+   * the stream.start response), so a session-less switch is by definition not
+   * the current viewer.
+   */
+  async viewerStreamSwitch(profileId, sessionId, input) {
+    const streamer = this.streamers.get(profileId);
+    if (!streamer)
+      throw new Error("no active viewer streamer for profile");
+    if (!sessionId || streamer.sessionId !== sessionId)
+      throw new Error("stale viewer session");
+    const tab = input?.tab;
+    if (tab === void 0 || tab === null || tab === "") {
+      throw new Error("stream.switch requires input.tab");
+    }
+    const cdpUrl = await this.host.withDaemonRecovery(() => this.resolveAccountPageCdpUrl(profileId, tab), `viewer stream.switch ${profileId}`);
+    await this.bringTargetToFront(cdpUrl);
+    const result = await this.streamerCommand(streamer, "switch", { cdpUrl });
+    streamer.streamedTabId = targetIdFromCdpUrl(cdpUrl);
+    return { ...result, streamed_tab_id: streamer.streamedTabId };
+  }
+  /**
+   * close — close an account tab via bb-browser, then, if the closed tab was
+   * the one being streamed, re-point the streamer at the profile's next active
+   * tab. Without the re-switch the streamer stays bound to a destroyed CDP
+   * target and the viewer goes black. Returns `streamed_tab_id` when a
+   * re-switch happened so the client can adopt the new active tab.
+   */
+  async viewerCloseTab(profileId, sessionId, input) {
+    const ref = viewerTabRef(input ?? {});
+    const closedTargetId = ref !== void 0 ? await this.accountTabTargetId(profileId, ref) : await this.accountActivePageTargetId(profileId);
+    const result = await this.viewerForwardNav(profileId, sessionId, "close", {
+      ...input ?? {},
+      tabId: closedTargetId
+    });
+    const streamer = this.streamers.get(profileId);
+    if (!streamer || !streamer.streamedTabId || streamer.streamedTabId !== closedTargetId) {
+      return result;
+    }
+    const cdpUrl = await this.host.withDaemonRecovery(() => this.resolveAccountPageCdpUrl(profileId), `viewer close re-switch ${profileId}`);
+    await this.bringTargetToFront(cdpUrl);
+    const sw = await this.streamerCommand(streamer, "switch", { cdpUrl });
+    streamer.streamedTabId = targetIdFromCdpUrl(cdpUrl);
+    return { ...result, ...sw, streamed_tab_id: streamer.streamedTabId };
+  }
+  /**
+   * Bring a CDP page target to the foreground via Chrome's DevTools HTTP
+   * endpoint (`/json/activate/{targetId}`, same host:port as the CDP ws). Chrome
+   * does not composite backgrounded tabs, so `Page.startScreencast` on a
+   * background tab yields zero frames (black viewer). Best-effort: a failure
+   * must not block the stream. host:port + targetId are parsed from the cdpUrl
+   * (`ws://host:port/devtools/page/<targetId>`) to avoid an extra /status call.
+   */
+  async bringTargetToFront(cdpUrl) {
+    const m = /^ws:\/\/([^/]+)\/devtools\/page\/(.+)$/.exec(cdpUrl);
+    if (!m)
+      return;
+    const [, hostPort, targetId] = m;
+    try {
+      const resp = await fetch(`http://${hostPort}/json/activate/${targetId}`, {
+        method: "GET",
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!resp.ok) {
+        this.host.log.warn(`[bb-viewer] activate target ${targetId} returned ${resp.status} (continuing)`);
+      }
+    } catch (err) {
+      this.host.log.warn(`[bb-viewer] activate target ${targetId} failed (continuing): ${formatErrorForLog(err)}`);
+    }
+  }
+  /**
+   * Forward a navigation command (tab_list/tab_new/open/reload/back/forward/
+   * close) to bb-browser scoped to the profile's account. This lets the human
+   * in the live viewer navigate and handle OAuth popups directly. Reuses the
+   * same account-scoped sendCommand path the agent invokes use.
+   *
+   * SECURITY — the `account` field alone does NOT scope tab addressing:
+   * bb-browser's ensurePageTarget resolves a client-supplied tab/tabId against
+   * EVERY page target in the shared Chrome (all accounts), and tab_list
+   * returns every tab with `account` as a mere annotation (verified in
+   * @pinixai/bb-browser-pro@0.15.0 dist/daemon.js ensurePageTarget/tab_list).
+   * On a multi-profile host that would let one profile's viewer list,
+   * navigate, and close other profiles' logged-in tabs. So before forwarding:
+   * (a) any tab ref must resolve through accountTabTargetId, which throws on
+   * tabs the profile's account does not own; (b) ref-less tab-addressed
+   * commands are pinned to the profile's own active tab instead of
+   * bb-browser's account-blind global current tab; (c) tab_list output is
+   * filtered to the profile's own rows; and (d) open/tab_new URLs must be
+   * http(s)/about:blank — file:// or chrome:// would read the host
+   * filesystem / browser internals straight into the video stream.
+   */
+  async viewerForwardNav(profileId, sessionId, command, input) {
+    if (command !== "tab_list") {
+      const streamer = this.streamers.get(profileId);
+      if (streamer && streamer.sessionId !== sessionId) {
+        throw new Error("stale viewer session");
+      }
+    }
+    return this.host.withDaemonRecovery(async () => {
+      await this.host.ensureAccount(profileId);
+      const request3 = { ...input ?? {} };
+      if (command === "open" || command === "tab_new") {
+        assertViewerNavigableUrl(request3.url);
+      }
+      const ref = viewerTabRef(request3);
+      if (ref !== void 0) {
+        request3.tabId = await this.accountTabTargetId(profileId, ref);
+        delete request3.tab;
+      } else if (REFLESS_PIN_NAV.has(command)) {
+        request3.tabId = await this.accountActivePageTargetId(profileId);
+      }
+      const result = await this.host.sendBrowserCommand({
+        ...request3,
+        method: command,
+        account: profileId
+      });
+      return command === "tab_list" ? filterTabListToAccount(result, profileId) : result;
+    }, `viewer ${command} ${profileId}`);
+  }
+  /**
+   * Resolve `ws://<cdpHost>:<cdpPort>/devtools/page/<targetId>` for a PAGE
+   * target owned by THIS profile's account — NOT bb-browser's global current
+   * tab (which `getCurrentTabCdpUrl`/`getTabCdpUrl` in the bundled daemon use
+   * via `cdp.currentTargetId`, an account-blind global; see daemon.js
+   * line ~10389/10410). When `tabRef` is given (stream.switch) we resolve that
+   * specific account tab; otherwise the profile's active page tab.
+   *
+   * Evidence from the installed @pinixai/bb-browser-pro@0.15.0 dist/daemon.js:
+   *  - GET /status (handleStatus, line ~1659-1668) returns `cdpHost` + `cdpPort`
+   *    — the CDP host/port the daemon's Chrome listens on.
+   *  - The CDP page ws URL format is `ws://<cdp.host>:<cdp.port>/devtools/page/<page.id>`
+   *    (getCurrentTabCdpUrl, line ~10392), where `page.id` is the full CDP
+   *    targetId (getTargets maps `t.targetId` → `.id`, line ~2461-2466).
+   *  - tab_list (command handler, line ~1041-1059) returns per-tab
+   *    `{ tabId: t.id, tab: <shortId>, account: <accountName>, url, ... }`, so
+   *    `tabId` is exactly the full targetId for the devtools URL and `account`
+   *    is the per-tab attribution we filter on (reused by findAccountTabOnHost).
+   */
+  async resolveAccountPageCdpUrl(profileId, tabRef) {
+    await this.host.ensureAccount(profileId);
+    const { host, port } = await this.host.cdpEndpoint();
+    const targetId = tabRef !== void 0 ? await this.accountTabTargetId(profileId, tabRef) : await this.accountActivePageTargetId(profileId);
+    return `ws://${host}:${port}/devtools/page/${targetId}`;
+  }
+  /**
+   * Full CDP targetId of the profile account's active page tab (the owned tab
+   * Chrome marks active, else the first owned tab). If the account owns no
+   * page tab yet, open `about:blank` for it first (mirrors the agent-invoke
+   * path's "always give a fresh account an owned tab" rule).
+   */
+  async accountActivePageTargetId(profileId) {
+    let targetId = await this.firstAccountPageTargetId(profileId);
+    if (targetId !== void 0)
+      return targetId;
+    await this.host.sendBrowserCommand({
+      method: "tab_new",
+      account: profileId,
+      url: "about:blank"
+    });
+    targetId = await this.firstAccountPageTargetId(profileId);
+    if (targetId === void 0) {
+      throw new Error(`no page tab found for profile account ${profileId}`);
+    }
+    return targetId;
+  }
+  /**
+   * Full CDP targetId (`tabId`) of the account's active page tab: the owned tab
+   * Chrome marks `active` when it belongs to this account, else the first owned
+   * tab (the global active flag is account-blind — another profile's tab may
+   * hold it, which must not leak here).
+   */
+  async firstAccountPageTargetId(profileId) {
+    const tabs = await this.accountTabs(profileId);
+    let firstOwned;
+    for (const t of tabs) {
+      if (t.account !== profileId)
+        continue;
+      const tabId = t.tabId;
+      if (typeof tabId !== "string" || !tabId)
+        continue;
+      if (t.active === true)
+        return tabId;
+      firstOwned ??= tabId;
+    }
+    return firstOwned;
+  }
+  /**
+   * Full CDP targetId for a specific account tab, addressed by the bb-browser
+   * short tab id (`tab`) or full target id (`tabId`). Used by stream.switch.
+   */
+  async accountTabTargetId(profileId, tabRef) {
+    const ref = String(tabRef);
+    const tabs = await this.accountTabs(profileId);
+    for (const t of tabs) {
+      if (t.account !== profileId)
+        continue;
+      const tabId = typeof t.tabId === "string" ? t.tabId : void 0;
+      const shortTab = t.tab === void 0 ? void 0 : String(t.tab);
+      if (tabId && tabId === ref || shortTab && shortTab === ref) {
+        if (!tabId)
+          break;
+        return tabId;
+      }
+    }
+    throw new Error(`tab ${ref} not found for profile account ${profileId}`);
+  }
+  /** `tab_list {account}` rows, typed to the fields we read (tabId/tab/account/active). */
+  async accountTabs(profileId) {
+    const list = await this.host.sendBrowserCommand({ method: "tab_list", account: profileId });
+    return Array.isArray(list.tabs) ? list.tabs : [];
+  }
+  // ---- bb-viewer streamer lifecycle ----
+  /**
+   * Spawn a bb-viewer streamer for the profile and wait until healthy. Binary
+   * is PRLL_BB_VIEWER_BIN (our image sets it to /usr/local/bin/bb-viewer),
+   * defaulting to `bb-viewer` on PATH — we NEVER download it. A free port is
+   * allocated per streamer. Stores the entry in `this.streamers` once healthy.
+   */
+  async spawnStreamer(profileId, sessionId, turn) {
+    if (this.stopping)
+      throw new Error("viewer streamer is shutting down");
+    const bin = process.env.PRLL_BB_VIEWER_BIN ?? "bb-viewer";
+    const port = await findFreePort();
+    const args = ["--api-only", "--port", String(port)];
+    const bindHost = process.env.PRLL_BB_VIEWER_HOST?.trim();
+    if (bindHost) {
+      if (!isLoopbackBindHost(bindHost)) {
+        throw new Error(`PRLL_BB_VIEWER_HOST must be loopback (127.0.0.1, localhost, ::1, [::1]) \u2014 refusing to bind bb-viewer's unauthenticated /command to ${bindHost}`);
+      }
+      args.push("--host", bindHost);
+    }
+    if (turn?.url) {
+      args.push("--turn-url", turn.url, "--turn-user", turn.username ?? "", "--turn-cred", turn.credential ?? "");
+    }
+    const streamerEnv = {};
+    for (const key of ["PATH", "HOME", "LANG", "LC_ALL", "TMPDIR", "DISPLAY"]) {
+      const val = process.env[key];
+      if (val !== void 0)
+        streamerEnv[key] = val;
+    }
+    this.host.log.info(`[bb-viewer] spawning for profile ${profileId} on port ${port}`);
+    const child = spawn3(bin, args, { stdio: ["ignore", "pipe", "pipe"], env: streamerEnv });
+    let childError = null;
+    child.once("error", (err) => {
+      childError = err;
+    });
+    child.once("exit", () => {
+      const current = this.streamers.get(profileId);
+      if (current?.child === child) {
+        this.streamers.delete(profileId);
+        this.host.log.warn(`[bb-viewer] streamer for ${profileId} exited; cleared stale entry`);
+      }
+    });
+    child.stdout?.on("data", (chunk) => {
+      const text = chunk.toString("utf8").trim();
+      if (text)
+        this.host.log.info(`[bb-viewer] ${text}`);
+    });
+    child.stderr?.on("data", (chunk) => {
+      const text = chunk.toString("utf8").trim();
+      if (text)
+        this.host.log.warn(`[bb-viewer] ${text}`);
+    });
+    const deadline = Date.now() + BB_VIEWER_HEALTH_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      if (this.stopping) {
+        this.killChild(child, "streamer for stopping daemon");
+        throw new Error("viewer streamer is shutting down");
+      }
+      if (childError) {
+        throw childError;
+      }
+      if (child.exitCode !== null || child.signalCode !== null) {
+        throw new Error("bb-viewer exited during startup");
+      }
+      try {
+        const resp = await fetch(`http://127.0.0.1:${port}/health`, {
+          signal: AbortSignal.timeout(2e3)
+        });
+        if (resp.ok) {
+          const streamer = { child, port, sessionId };
+          this.streamers.set(profileId, streamer);
+          this.host.log.info(`[bb-viewer] ready for profile ${profileId} on port ${port}`);
+          return streamer;
+        }
+      } catch {
+      }
+      await sleep(200);
+    }
+    this.killChild(child, "unhealthy streamer");
+    throw new Error("bb-viewer did not become healthy in time");
+  }
+  /**
+   * SIGTERM with a SIGKILL escalation: a bb-viewer that hangs or ignores TERM
+   * would otherwise outlive its teardown holding the port + CDP session (the
+   * shell-level pattern-kill only exists on the hosted pod, not BYOC). The
+   * escalation timer is unref'd so it never holds the daemon open; it is
+   * cleared on exit. Caveat: a daemon process that exits immediately after
+   * shutdown() abandons the timer — acceptable, the TERM was still sent.
+   */
+  killChild(child, label) {
+    if (child.exitCode !== null || child.signalCode !== null)
+      return;
+    try {
+      child.kill("SIGTERM");
+    } catch {
+      return;
+    }
+    const killTimer = setTimeout(() => {
+      if (child.exitCode === null && child.signalCode === null) {
+        this.host.log.warn(`[bb-viewer] ${label} ignored SIGTERM; escalating to SIGKILL`);
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }
+    }, BB_VIEWER_TERM_GRACE_MS);
+    killTimer.unref?.();
+    child.once("exit", () => clearTimeout(killTimer));
+  }
+  /**
+   * POST a command to the profile's bb-viewer `/command` endpoint. Parses the
+   * `{result}` / `{error:{message}}` envelope (bb-viewer api.go) and returns
+   * the inner result, throwing the error message on failure.
+   */
+  async streamerCommand(streamer, method, params) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), BB_VIEWER_COMMAND_TIMEOUT_MS);
+    try {
+      const resp = await fetch(`http://127.0.0.1:${streamer.port}/command`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ method, params }),
+        signal: controller.signal
+      });
+      const text = await resp.text();
+      const parsed = text ? JSON.parse(text) : {};
+      if (parsed.error) {
+        throw new Error(parsed.error.message || `bb-viewer ${method} failed`);
+      }
+      if (!resp.ok) {
+        throw new Error(`bb-viewer ${method} returned ${resp.status}: ${text}`);
+      }
+      return parsed.result ?? {};
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /**
+   * Kill + remove the profile's bb-viewer streamer, if any. Idempotent. Also
+   * clears any kick marker for the profile: a (re)kill establishes a clean
+   * streamer slot, so a subsequent stream.start starts un-kicked. viewerKick
+   * re-records the kicked session AFTER calling this.
+   */
+  killProfileStreamer(profileId) {
+    this.kickedSessions.delete(profileId);
+    const streamer = this.streamers.get(profileId);
+    if (!streamer)
+      return;
+    this.streamers.delete(profileId);
+    this.killChild(streamer.child, `streamer for ${profileId}`);
+  }
+  /**
+   * Tear down every profile streamer and refuse new spawns (daemon stop).
+   * Idempotent.
+   */
+  shutdown() {
+    this.stopping = true;
+    for (const profileId of [...this.streamers.keys()]) {
+      this.killProfileStreamer(profileId);
+    }
+  }
+};
+function targetIdFromCdpUrl(cdpUrl) {
+  return /\/devtools\/page\/(.+)$/.exec(cdpUrl)?.[1];
+}
+var REFLESS_PIN_NAV = /* @__PURE__ */ new Set(["reload", "back", "forward", "close"]);
+function viewerTabRef(request3) {
+  for (const key of ["tabId", "tab"]) {
+    const v = request3[key];
+    if (typeof v === "string" && v !== "" || typeof v === "number")
+      return String(v);
+  }
+  return void 0;
+}
+var VIEWER_NAVIGABLE_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
+function assertViewerNavigableUrl(raw) {
+  if (raw === void 0 || raw === null || raw === "")
+    return;
+  if (typeof raw !== "string")
+    throw new Error("url must be a string");
+  if (raw === "about:blank")
+    return;
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    throw new Error(`invalid url: ${raw}`);
+  }
+  if (!VIEWER_NAVIGABLE_PROTOCOLS.has(parsed.protocol)) {
+    throw new Error(`url scheme not allowed in the live viewer: ${parsed.protocol.replace(/:$/, "")}`);
+  }
+}
+function filterTabListToAccount(result, account) {
+  const tabs = Array.isArray(result.tabs) ? result.tabs : [];
+  const owned = tabs.filter((t) => t?.account === account);
+  return { ...result, tabs: owned, activeIndex: owned.findIndex((t) => t?.active === true) };
+}
+
+// ts/daemon/dist/clip-runtime/browser-profile-manager.js
 var BB_BROWSER_DAEMON_START_TIMEOUT_MS = 15e3;
 var BrowserCommandError = class extends Error {
   method;
@@ -32027,9 +32921,20 @@ var BrowserProfileManager = class {
   ensuredAccounts = /* @__PURE__ */ new Set();
   ensuringAccounts = /* @__PURE__ */ new Map();
   reportedStatuses = /* @__PURE__ */ new Map();
+  // Live viewer orchestration (bb-viewer streamer subprocesses + viewer nav)
+  // lives in BrowserViewerStreamer; the manager hands it the account-scoped
+  // bb-browser command path via the host interface.
+  viewer;
   constructor(opts) {
     this.opts = opts;
     mkdirSync5(this.opts.homeDir, { recursive: true });
+    this.viewer = new BrowserViewerStreamer({
+      log: this.opts.log,
+      sendBrowserCommand: (request3) => this.sendCommand(request3),
+      ensureAccount: (account) => this.ensureAccount(account),
+      withDaemonRecovery: (operation, label) => this.withDaemonRecovery(operation, label),
+      cdpEndpoint: () => this.cdpEndpoint()
+    });
   }
   async invoke({ profileId, account, command, input }) {
     if (!profileId)
@@ -32096,12 +33001,14 @@ var BrowserProfileManager = class {
     if (!profileId)
       throw new Error("browser profile id is required");
     this.reportedStatuses.delete(profileId);
+    this.viewer.killProfileStreamer(profileId);
     this.reportStatus(profileId, "stopped");
   }
   async resetProfile(profileId) {
     if (!profileId)
       throw new Error("browser profile id is required");
     this.reportedStatuses.delete(profileId);
+    this.viewer.killProfileStreamer(profileId);
     try {
       await this.withDaemonRecovery(() => this.resetProfileOnce(profileId), `reset profile ${profileId}`);
       this.reportStatus(profileId, "stopped");
@@ -32112,6 +33019,7 @@ var BrowserProfileManager = class {
     }
   }
   async stop() {
+    this.viewer.shutdown();
     const daemon = this.daemon;
     this.daemon = null;
     this.starting = null;
@@ -32128,6 +33036,25 @@ var BrowserProfileManager = class {
       daemon.child.kill("SIGTERM");
     }
   }
+  /**
+   * Viewer control command entrypoint — delegates to BrowserViewerStreamer
+   * (browser-viewer-streamer.ts), which owns the per-profile bb-viewer
+   * subprocesses and viewer tab navigation.
+   */
+  async handleViewerCommand(profileId, sessionId, command, input, turn) {
+    return this.viewer.handleViewerCommand(profileId, sessionId, command, input, turn);
+  }
+  /** Read cdpHost/cdpPort from the bb-browser daemon `GET /status`. */
+  async cdpEndpoint() {
+    const daemon = await this.ensureDaemon();
+    const status = await this.post("/status", daemon, void 0, 5e3);
+    const host = status.cdpHost?.trim();
+    const port = status.cdpPort;
+    if (!host || typeof port !== "number" || !Number.isFinite(port)) {
+      throw new Error("bb-browser /status did not report a CDP endpoint");
+    }
+    return { host, port };
+  }
   async prepareOpenProfile(profileId, url) {
     const accountCreated = await this.ensureAccount(profileId, url !== "about:blank" ? url : void 0);
     await this.sendCommand({ method: "tab_list", account: profileId });
@@ -32386,7 +33313,7 @@ var BrowserProfileManager = class {
     const port = await findFreePort();
     const token = randomToken();
     const daemonPath = resolveBbBrowserDaemonPath();
-    const child = spawn3(process.execPath, [daemonPath, "--host", host, "--port", String(port), "--token", token], {
+    const child = spawn4(process.execPath, [daemonPath, "--host", host, "--port", String(port), "--token", token], {
       env: {
         ...process.env,
         BB_BROWSER_HOME: this.opts.homeDir
@@ -32500,10 +33427,6 @@ function comparableUrl(url) {
     return null;
   }
 }
-function formatErrorForLog(err) {
-  const message = err instanceof Error ? err.message : String(err);
-  return message.replace(/\s+/g, " ").slice(0, 300);
-}
 function resolveBbBrowserDaemonPath() {
   const sibling = path9.join(path9.dirname(fileURLToPath(import.meta.url)), "bb-browser-daemon.js");
   if (existsSync8(sibling))
@@ -32518,29 +33441,9 @@ function resolveBbBrowserDaemonPath() {
   }
   return full;
 }
-async function findFreePort() {
-  return new Promise((resolve8, reject) => {
-    const server = net.createServer();
-    server.unref();
-    server.on("error", reject);
-    server.listen(0, "127.0.0.1", () => {
-      const address = server.address();
-      server.close(() => {
-        if (address && typeof address === "object") {
-          resolve8(address.port);
-        } else {
-          reject(new Error("failed to allocate free port"));
-        }
-      });
-    });
-  });
-}
 function randomToken() {
   return randomBytes(16).toString("hex");
 }
-function sleep(ms) {
-  return new Promise((resolve8) => setTimeout(resolve8, ms));
-}
 
 // ts/daemon/dist/supervisor.js
 init_config();
@@ -32940,7 +33843,7 @@ function shellQuote(value) {
 }
 
 // ts/daemon/dist/workspace.js
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
 import * as fs11 from "node:fs";
 import * as path12 from "node:path";
@@ -33244,7 +34147,7 @@ function runCommand(cmd, args, cwd, timeoutMs = 12e4, env = process.env) {
         clearTimeout(killTimer);
       fn();
     };
-    const child = spawn4(cmd, args, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn5(cmd, args, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
     timeoutTimer = setTimeout(() => {
       timedOut = true;
       child.kill("SIGTERM");
@@ -33397,7 +34300,12 @@ var DaemonSupervisor = class {
   children = /* @__PURE__ */ new Map();
   spawningAgents = /* @__PURE__ */ new Set();
   pendingWorkspaceSetup = /* @__PURE__ */ new Set();
-  browserProfileLifecycleQueues = /* @__PURE__ */ new Map();
+  // ONE queue per profile for BOTH lifecycle (open/stop/reset) and viewer
+  // (stream.*/nav) commands. They mutate the same streamer + account state, so
+  // two independent queues would let a stop/reset interleave with an in-flight
+  // stream.start (the kill fires before the streamer registers and misses it,
+  // leaving a live streamer on a profile the server just marked stopped).
+  browserProfileOpQueues = /* @__PURE__ */ new Map();
   workspaceSetupRetryTimers = /* @__PURE__ */ new Map();
   cancelledSpawns = /* @__PURE__ */ new Set();
   ws = null;
@@ -33558,6 +34466,10 @@ var DaemonSupervisor = class {
       this.log.info(`WS: browser profile lifecycle requested \u2014 profile=${data.profile_id} action=${data.action}`);
       void this.enqueueBrowserProfileLifecycle(data);
     });
+    this.ws.on("machine.browser_profile.viewer", (data) => {
+      this.log.info(`WS: browser profile viewer command \u2014 profile=${data.profile_id} command=${data.command}`);
+      this.enqueueBrowserProfileViewer(data);
+    });
     this.ws.onStateChange((state) => {
       if (state === "disconnected" || state === "reconnecting") {
         this.log.warn(`machine WS state: ${state}`);
@@ -33707,10 +34619,13 @@ var DaemonSupervisor = class {
     for (const profile of profiles) {
       if (profile.status !== "running" && profile.status !== "pending")
         continue;
+      if (!profile.machine_id)
+        continue;
+      const machineId = profile.machine_id;
       try {
         if (profile.status === "pending") {
           await this.enqueueBrowserProfileLifecycle({
-            machine_id: profile.machine_id,
+            machine_id: machineId,
             profile_id: profile.id,
             action: "open"
           });
@@ -33869,17 +34784,45 @@ var DaemonSupervisor = class {
     }
   }
   enqueueBrowserProfileLifecycle(data) {
-    const previous = this.browserProfileLifecycleQueues.get(data.profile_id) ?? Promise.resolve();
+    return this.enqueueBrowserProfileOp(data.profile_id, () => this.handleBrowserProfileLifecycle(data));
+  }
+  enqueueBrowserProfileOp(profileId, op) {
+    const previous = this.browserProfileOpQueues.get(profileId) ?? Promise.resolve();
     const next = previous.catch(() => {
-    }).then(() => this.handleBrowserProfileLifecycle(data));
-    this.browserProfileLifecycleQueues.set(data.profile_id, next);
+    }).then(op);
+    this.browserProfileOpQueues.set(profileId, next);
     void next.finally(() => {
-      if (this.browserProfileLifecycleQueues.get(data.profile_id) === next) {
-        this.browserProfileLifecycleQueues.delete(data.profile_id);
+      if (this.browserProfileOpQueues.get(profileId) === next) {
+        this.browserProfileOpQueues.delete(profileId);
       }
     });
     return next;
   }
+  /**
+   * Handle one viewer control command and reply via REST. Always answers the
+   * request/reply bridge exactly once ({result} on success, {error:{message}}
+   * on failure) and never throws into the WS event loop — mirrors
+   * handleFilesystemBrowse. Serialized per profile by enqueueBrowserProfileViewer.
+   */
+  async handleBrowserProfileViewer(data) {
+    if (!this.browserProfileManager) {
+      await this.client.postBrowserProfileViewerResponse(data.request_id, {
+        error: { message: "Browser profile runtime is disabled on this daemon" }
+      }).catch((err) => this.log.warn(`browser profile viewer negative ACK failed: ${String(err)}`));
+      return;
+    }
+    try {
+      const result = await this.browserProfileManager.handleViewerCommand(data.profile_id, data.session_id, data.command, data.input, data.turn);
+      await this.client.postBrowserProfileViewerResponse(data.request_id, { result });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.log.warn(`browser profile viewer command failed (profile=${data.profile_id}, command=${data.command}): ${message}`);
+      await this.client.postBrowserProfileViewerResponse(data.request_id, { error: { message } }).catch((replyErr) => this.log.warn(`browser profile viewer error ACK failed: ${String(replyErr)}`));
+    }
+  }
+  enqueueBrowserProfileViewer(data) {
+    void this.enqueueBrowserProfileOp(data.profile_id, () => this.handleBrowserProfileViewer(data));
+  }
   async handleClipSync(_data) {
     await this.reconcileMachineClips();
   }
@@ -33938,7 +34881,7 @@ var DaemonSupervisor = class {
     }
     if (changed) {
       this.log.info(`machine clips synced \u2014 count=${desired.length}`);
-      await this.reconnectClipProvider();
+      this.clipProvider?.reregister();
     }
   }
   startClipReconcileTimer() {
@@ -34067,15 +35010,6 @@ var DaemonSupervisor = class {
     }
     return null;
   }
-  async reconnectClipProvider() {
-    if (!this.clipProvider)
-      return;
-    const provider = this.clipProvider;
-    this.clipProvider = null;
-    this.connectedClipServiceUrl = null;
-    await provider.disconnect().catch((err) => this.log.warn(`clip provider reconnect disconnect failed: ${String(err)}`));
-    await this.applyClipProviderState();
-  }
   async handleWorkspaceSetupRequested(agentId) {
     if (this.spawningAgents.has(agentId)) {
       this.log.info(`agent ${agentId}: workspace setup already in progress; queueing one restart`);
@@ -34356,7 +35290,7 @@ var DaemonSupervisor = class {
     const env = adapter.buildEnv(baseEnv, state.agentId, state.orgId, state.credential.api_key, dirs, effectiveProviderConfig);
     const spawnCmd = adapter.args.length > 0 ? `${adapter.bin} ${adapter.args.join(" ")}` : adapter.bin;
     this.log.info(`spawning agent ${state.agentId} runtime=${state.runtimeType} cmd=${spawnCmd} (attempt ${state.restartAttempts + 1})`);
-    const child = spawn5(adapter.bin, adapter.args, {
+    const child = spawn6(adapter.bin, adapter.args, {
       env,
       stdio: ["ignore", "inherit", "inherit"],
       detached: false