@schoolai/shipyard 3.0.0 → 3.1.0-rc.20260414.0

package/dist/{serve-LL6LUMZI.js → serve-KBBJR56G.js}

@@ -37,7 +37,7 @@ import {
   VaultKeyPutRequestSchema,
   VaultKeyPutResponseSchema,
   classifyClaudeCodeCompatibility
-} from "./chunk-QMLEP5EE.js";
+} from "./chunk-E747QA24.js";
 import {
   loadAuthToken
 } from "./chunk-IHSXN66C.js";
@@ -76,7 +76,7 @@ import { execSync } from "child_process";
 import { existsSync as existsSync7 } from "fs";
 import { mkdir as mkdir18 } from "fs/promises";
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname14, join as join42 } from "path";
+import { dirname as dirname14, join as join43 } from "path";
 import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
 
 // ../../node_modules/.pnpm/@loro-extended+change@6.0.0-beta.0_loro-crdt@1.10.6/node_modules/@loro-extended/change/dist/index.js
@@ -7262,6 +7262,243 @@ var Adapter = class {
     this.#sendInterceptors = [];
   }
 };
+var Bridge = class {
+  adapters = /* @__PURE__ */ new Map();
+  logger;
+  constructor({ logger: logger2 } = {}) {
+    this.logger = logger2 ?? getLogger(["@loro-extended", "repo"]);
+  }
+  /**
+   * Register an adapter with this bridge
+   */
+  addAdapter(adapter) {
+    if (!adapter.adapterType)
+      throw new Error("can't add adapter without adapter id");
+    this.adapters.set(adapter.adapterType, adapter);
+  }
+  /**
+   * Remove an adapter from this bridge
+   */
+  removeAdapter(adapterType) {
+    this.adapters.delete(adapterType);
+  }
+  /**
+   * Route a message from one adapter to another
+   */
+  routeMessage(fromAdapterType, toAdapterType, message) {
+    this.logger.trace("routeMessage: {messageType} from {from} to {to}", {
+      from: fromAdapterType,
+      to: toAdapterType,
+      messageType: message.type
+    });
+    const toAdapter = this.adapters.get(toAdapterType);
+    if (toAdapter) {
+      toAdapter.deliverMessage(fromAdapterType, message);
+    } else {
+      this.logger.warn(
+        "routeMessage: target adapter {toAdapterType} not found",
+        { toAdapterType }
+      );
+    }
+  }
+  /**
+   * Get all adapter IDs currently in the bridge
+   */
+  get adapterTypes() {
+    return new Set(this.adapters.keys());
+  }
+};
+var BridgeAdapter = class extends Adapter {
+  bridge;
+  logger;
+  // Track which remote adapter each channel connects to
+  channelToAdapter = /* @__PURE__ */ new Map();
+  adapterToChannel = /* @__PURE__ */ new Map();
+  constructor({ adapterType, adapterId, bridge, logger: logger2 }) {
+    super({ adapterType, adapterId: adapterId ?? adapterType });
+    this.bridge = bridge;
+    this.logger = (logger2 ?? getLogger(["@loro-extended", "repo"])).with({
+      adapterType
+    });
+    this.logger.trace(`new BridgeAdapter`);
+  }
+  generate(context) {
+    this.logger.debug("generate channel to {targetAdapterType}", {
+      targetAdapterType: context.targetAdapterType
+    });
+    return {
+      adapterType: this.adapterType,
+      kind: "network",
+      send: (msg) => {
+        this.logger.debug("channel.send: {messageType} from {from} to {to}", {
+          from: this.adapterType,
+          to: context.targetAdapterType,
+          messageType: msg.type
+        });
+        this.bridge.routeMessage(
+          this.adapterType,
+          context.targetAdapterType,
+          msg
+        );
+      },
+      stop: () => {
+      }
+    };
+  }
+  /**
+   * Start participating in the in-process network.
+   * Uses two-phase initialization:
+   * 1. Create all channels (no messages sent)
+   * 2. Establish channels (only the "newer" adapter initiates to avoid double-establishment)
+   */
+  async onStart() {
+    this.logger.trace(`onStart - registering with bridge`);
+    this.bridge.addAdapter(this);
+    for (const [adapterType, adapter] of this.bridge.adapters) {
+      if (adapterType !== this.adapterType) {
+        this.logger.trace("telling {adapterType} to create channel to us", {
+          adapterType
+        });
+        adapter.createChannelTo(this.adapterType);
+      }
+    }
+    for (const adapterType of this.bridge.adapters.keys()) {
+      if (adapterType !== this.adapterType) {
+        this.logger.trace("creating our channel to {adapterType}", {
+          adapterType
+        });
+        this.createChannelTo(adapterType);
+      }
+    }
+    for (const channelId of this.adapterToChannel.values()) {
+      this.logger.trace("establishing our channel {channelId}", { channelId });
+      this.establishChannel(channelId);
+    }
+    this.logger.trace(`onStart complete`);
+  }
+  /**
+   * Stop participating in the in-process network.
+   * Cleans up all channels and removes from bridge.
+   */
+  async onStop() {
+    this.logger.trace(`stop`);
+    for (const [adapterType, adapter] of this.bridge.adapters) {
+      if (adapterType !== this.adapterType) {
+        adapter.removeChannelTo(this.adapterType);
+      }
+    }
+    this.bridge.removeAdapter(this.adapterType);
+    for (const channelId of this.channelToAdapter.keys()) {
+      this.removeChannel(channelId);
+    }
+    this.channelToAdapter.clear();
+    this.adapterToChannel.clear();
+  }
+  /**
+   * Create a channel to a target adapter (Phase 1).
+   * Does NOT trigger establishment - that happens in Phase 2.
+   * Called by our own onStart() or by other adapters when they start.
+   */
+  createChannelTo(targetAdapterType) {
+    if (this.adapterToChannel.has(targetAdapterType)) {
+      this.logger.trace("channel already exists to {targetAdapterType}", {
+        targetAdapterType
+      });
+      return;
+    }
+    const channel = this.addChannel({ targetAdapterType });
+    this.channelToAdapter.set(channel.channelId, targetAdapterType);
+    this.adapterToChannel.set(targetAdapterType, channel.channelId);
+    this.logger.trace(
+      "channel {channelId} created (not yet established) to {targetAdapterType}",
+      {
+        targetAdapterType,
+        channelId: channel.channelId
+      }
+    );
+  }
+  /**
+   * Establish a channel to a target adapter (Phase 2).
+   * Triggers the establishment handshake.
+   * Called by our own onStart() or by other adapters when they start.
+   */
+  establishChannelTo(targetAdapterType) {
+    const channelId = this.adapterToChannel.get(targetAdapterType);
+    if (!channelId) {
+      this.logger.warn("no channel found to establish to {targetAdapterType}", {
+        targetAdapterType
+      });
+      return;
+    }
+    this.logger.trace("establishing channel {channelId}", { channelId });
+    this.establishChannel(channelId);
+  }
+  /**
+   * Remove a channel to a target adapter.
+   * Called by other adapters when they stop.
+   */
+  removeChannelTo(targetAdapterType) {
+    const channelId = this.adapterToChannel.get(targetAdapterType);
+    if (channelId) {
+      this.logger.trace("removing channel to adapter {targetAdapterType}", {
+        targetAdapterType
+      });
+      this.removeChannel(channelId);
+      this.channelToAdapter.delete(channelId);
+      this.adapterToChannel.delete(targetAdapterType);
+    }
+  }
+  /**
+   * Deliver a message from another adapter to the appropriate channel.
+   * Called by Bridge.routeMessage().
+   *
+   * Delivers messages asynchronously via queueMicrotask() to simulate real
+   * network adapter behavior. This ensures tests using BridgeAdapter exercise
+   * the same async codepaths as production adapters (WebSocket, SSE, etc.).
+   *
+   * Tests should use `waitForSync()` or `waitUntilReady()` to await sync completion.
+   */
+  deliverMessage(fromAdapterType, message) {
+    const channelId = this.adapterToChannel.get(fromAdapterType);
+    if (channelId) {
+      const channel = this.channels.get(channelId);
+      if (channel) {
+        this.logger.trace(
+          "queueing message {messageType} to channel {channelId} from {from}",
+          {
+            from: fromAdapterType,
+            messageType: message.type,
+            channelId
+          }
+        );
+        queueMicrotask(() => {
+          this.logger.trace(
+            "delivering message {messageType} to channel {channelId} from {from}",
+            {
+              from: fromAdapterType,
+              messageType: message.type,
+              channelId
+            }
+          );
+          channel.onReceive(message);
+        });
+      } else {
+        this.logger.warn(
+          "channel {channelId} not found for message delivery from {fromAdapterType}",
+          {
+            fromAdapterType,
+            channelId
+          }
+        );
+      }
+    } else {
+      this.logger.warn("no channel found for adapter {fromAdapterType}", {
+        fromAdapterType,
+        availableChannels: Array.from(this.adapterToChannel.keys())
+      });
+    }
+  }
+};
 function isEstablished(channel) {
   return channel.type === "established";
 }
@@ -24374,6 +24611,7 @@ function parseDocumentId(id) {
     return null;
   return { prefix, key, epoch };
 }
+var LORO_BACKPRESSURE_HIGH_WATER = 1024 * 1024;
 var HARNESS_SERVER_NAME = "shipyard-harness";
 var VISUALIZE_READ_ME_TOOL = "read_me";
 var VISUALIZE_TOOL = "visualize";
@@ -24828,6 +25066,47 @@ var PRStatePayloadSchema = external_exports.object({
   requiredChecks: external_exports.array(external_exports.string()).default([]),
   updatedAt: external_exports.number()
 });
+function applyPresenceUpdate(pool2, peerId, identity, state) {
+  const existing = pool2[peerId];
+  const mergedState = {
+    ...existing?.state,
+    ...state
+  };
+  if (state.typing === void 0 && "typing" in state) {
+    delete mergedState.typing;
+  }
+  if (state.viewing === void 0 && "viewing" in state) {
+    delete mergedState.viewing;
+  }
+  return {
+    ...pool2,
+    [peerId]: {
+      userId: identity.userId,
+      username: identity.username,
+      avatarUrl: identity.avatarUrl,
+      state: mergedState
+    }
+  };
+}
+function removePresence(pool2, peerId) {
+  const { [peerId]: _2, ...rest } = pool2;
+  return rest;
+}
+var PeerPresenceStateSchema = external_exports.object({
+  typing: external_exports.object({
+    taskId: external_exports.string(),
+    context: external_exports.string()
+  }).optional(),
+  viewing: external_exports.object({
+    taskId: external_exports.string()
+  }).optional()
+});
+var PeerPresenceSlotSchema = external_exports.object({
+  userId: external_exports.string(),
+  username: external_exports.string(),
+  avatarUrl: external_exports.string().nullable(),
+  state: PeerPresenceStateSchema
+});
 var ASSET_CHUNK_SIZE = 16384;
 var ASSET_REQUEST_ID_BYTES = 36;
 var ASSET_TRANSFER_LABEL = "asset-transfer";
@@ -25768,6 +26047,10 @@ var BrowserToDaemonControlMessageSchema = external_exports.discriminatedUnion("t
     type: external_exports.literal("remove_worktree"),
     worktreePath: external_exports.string()
   }),
+  external_exports.object({
+    type: external_exports.literal("list_directories"),
+    basePath: external_exports.string()
+  }),
   external_exports.object({
     type: external_exports.literal("create_task"),
     taskId: external_exports.string(),
@@ -25792,6 +26075,11 @@ var BrowserToDaemonControlMessageSchema = external_exports.discriminatedUnion("t
     value: external_exports.unknown()
   }),
   external_exports.object({ type: external_exports.literal("request_user_settings") }),
+  external_exports.object({
+    type: external_exports.literal("request_preview_target"),
+    port: external_exports.number().int().positive().optional(),
+    url: external_exports.string().url().optional()
+  }),
   external_exports.object({
     type: external_exports.literal("add_annotation"),
     taskId: external_exports.string(),
@@ -25847,6 +26135,11 @@ var BrowserToDaemonControlMessageSchema = external_exports.discriminatedUnion("t
   external_exports.object({ type: external_exports.literal("delete_template"), templateId: external_exports.string() }),
   external_exports.object({ type: external_exports.literal("list_templates") }),
   external_exports.object({ type: external_exports.literal("stop_task"), taskId: external_exports.string() }),
+  external_exports.object({
+    type: external_exports.literal("stop_background_agent"),
+    taskId: external_exports.string(),
+    backgroundTaskId: external_exports.string()
+  }),
   external_exports.object({
     type: external_exports.literal("todo_item_added"),
     taskId: external_exports.string(),
@@ -25881,6 +26174,14 @@ var BrowserToDaemonControlMessageSchema = external_exports.discriminatedUnion("t
     depId: external_exports.string(),
     depContent: external_exports.string(),
     action: external_exports.enum(["connected", "disconnected"])
+  }),
+  external_exports.object({
+    type: external_exports.literal("request_recent_logs"),
+    windowMinutes: external_exports.number().int().positive().max(120).default(30)
+  }),
+  external_exports.object({
+    type: external_exports.literal("presence_update"),
+    state: PeerPresenceStateSchema
   })
 ]);
 var DaemonToBrowserControlMessageSchema = external_exports.discriminatedUnion("type", [
@@ -25974,7 +26275,8 @@ var DaemonToBrowserControlMessageSchema = external_exports.discriminatedUnion("t
   }),
   external_exports.object({
     type: external_exports.literal("detected_ports"),
-    ports: external_exports.array(DetectedPortSchema)
+    ports: external_exports.array(DetectedPortSchema),
+    proxyPort: external_exports.number().optional()
   }),
   external_exports.object({
     type: external_exports.literal("set_preview_target"),
@@ -26056,6 +26358,11 @@ var DaemonToBrowserControlMessageSchema = external_exports.discriminatedUnion("t
     type: external_exports.literal("worktree_removed"),
     worktreePath: external_exports.string()
   }),
+  external_exports.object({
+    type: external_exports.literal("directory_list"),
+    basePath: external_exports.string(),
+    directories: external_exports.array(external_exports.string())
+  }),
   external_exports.object({
     type: external_exports.literal("task_index_snapshot"),
     tasks: external_exports.record(external_exports.string(), TaskRecordSchema),
@@ -26247,6 +26554,15 @@ var DaemonToBrowserControlMessageSchema = external_exports.discriminatedUnion("t
     taskId: external_exports.string(),
     error: external_exports.string(),
     errorKind: TaskErrorKindSchema
+  }),
+  external_exports.object({
+    type: external_exports.literal("recent_logs"),
+    lines: external_exports.array(external_exports.string()),
+    truncated: external_exports.boolean()
+  }),
+  external_exports.object({
+    type: external_exports.literal("presence_state"),
+    peers: external_exports.record(external_exports.string(), PeerPresenceSlotSchema)
   })
 ]);
 var TASK_MESSAGES_PREFIX = "task-messages:";
@@ -26645,14 +26961,6 @@ function structuredTaskToCCFile(task) {
     updatedAt: task.updatedAt
   };
 }
-var TaskViewPresenceShape = Shape.plain.struct({
-  userId: Shape.plain.string(),
-  username: Shape.plain.string(),
-  avatarUrl: Shape.plain.string(),
-  taskId: Shape.plain.string(),
-  timestamp: Shape.plain.number()
-});
-var TaskViewDocSchema = Shape.doc({}, { mergeable: true });
 var TODO_ITEM_STATUSES = ["pending", "in_progress", "completed"];
 function generateTodoId(content) {
   let hash = 5381;
@@ -27504,14 +27812,25 @@ function runWithTimeout(command2, args, cwd, timeoutMs) {
 }
 
 // src/shared/capabilities/git-repo.ts
+var ghAvailableCache = false;
 async function isGhAvailable() {
+  if (ghAvailableCache) return true;
   try {
     await run("which", ["gh"]);
+    ghAvailableCache = true;
     return true;
   } catch {
     return false;
   }
 }
+var topLevelCache = /* @__PURE__ */ new Map();
+async function getGitTopLevel(cwd) {
+  const cached = topLevelCache.get(cwd);
+  if (cached !== void 0) return cached;
+  const topLevel = (await runWithTimeout("git", ["rev-parse", "--show-toplevel"], cwd, TIMEOUT_MS)).trim();
+  topLevelCache.set(cwd, topLevel);
+  return topLevel;
+}
 function parseOwnerRepo(remoteUrl) {
   const match2 = remoteUrl.match(/github\.com[:/]([^/]+)\/([^/.]+)/);
   if (!match2?.[1] || !match2[2]) return null;
@@ -29186,7 +29505,7 @@ function nanoid(size2 = 21) {
 }
 
 // src/services/bootstrap/signaling.ts
-var DAEMON_NPM_VERSION = true ? "3.0.0" : "unknown";
+var DAEMON_NPM_VERSION = true ? "3.1.0" : "unknown";
 function createDaemonSignaling(config2) {
   const agentId = config2.agentId ?? nanoid();
   function send(msg) {
@@ -30802,7 +31121,7 @@ function handlePluginAuthRequest(pluginId, sendControl, deps, logAdapter) {
 }
 
 // src/services/pr-poller.ts
-var PR_POLL_INTERVAL_MS = 6e4;
+var PR_POLL_INTERVAL_MS = 3e4;
 async function enrichClosedPR(pr, cwd) {
   if (pr.state !== "closed" || pr.mergeCommitSha) return pr;
   if (!pr.headRefSha) return pr;
@@ -30813,10 +31132,9 @@ async function enrichClosedPR(pr, cwd) {
   );
   return headInBase ? { ...pr, headCommitInBase: true } : pr;
 }
-async function fetchCIData(pr, cwd) {
+async function fetchCIDataWithRemote(pr, cwd, remote) {
   const referenceCommit = pr?.mergeCommitSha ?? pr?.headRefSha ?? await run("git", ["rev-parse", "HEAD"], cwd).catch(() => "");
   if (!referenceCommit) return { deployments: [], workflowRuns: [], requiredChecks: [] };
-  const remote = await run("git", ["remote", "get-url", "origin"], cwd).catch(() => "");
   const parsed = parseOwnerRepo(remote);
   if (!parsed) return { deployments: [], workflowRuns: [], requiredChecks: [] };
   const branch = pr?.baseRef ?? "main";
@@ -30843,13 +31161,14 @@ async function fetchCIData(pr, cwd) {
   const allDeployments = [...deployments, ...placeholderDeployments];
   return { deployments: allDeployments, workflowRuns, requiredChecks };
 }
-function createPRPoller(callbacks, log) {
-  const polls = /* @__PURE__ */ new Map();
-  async function fetchPRState(taskId, cwd) {
+function createPRPoller(callbacks, log, resolveTopLevel = getGitTopLevel) {
+  const repos = /* @__PURE__ */ new Map();
+  const taskToRepo = /* @__PURE__ */ new Map();
+  let disposed = false;
+  async function fetchPRState(cwd) {
     const available = await isGhAvailable();
     if (!available) {
       return {
-        taskId,
         prAvailable: false,
         currentBranchPR: null,
         assignedReviews: [],
@@ -30860,14 +31179,14 @@ function createPRPoller(callbacks, log) {
         updatedAt: Date.now()
       };
     }
-    const [currentPR, assigned, user] = await Promise.allSettled([
-      getPRForCurrentBranch(cwd),
-      getAssignedReviews(cwd),
-      getUserPRs(cwd)
+    const [prResults, remote] = await Promise.all([
+      Promise.allSettled([getPRForCurrentBranch(cwd), getAssignedReviews(cwd), getUserPRs(cwd)]),
+      run("git", ["remote", "get-url", "origin"], cwd).catch(() => "")
     ]);
+    const [currentPR, assigned, user] = prResults;
     const { allPRs: _2, currentBranchPR: rawPR } = deduplicatePRs(currentPR, assigned, user);
     const currentBranchPR = rawPR ? await enrichClosedPR(rawPR, cwd) : null;
-    const ciData = await fetchCIData(currentBranchPR, cwd).catch(
+    const ciData = await fetchCIDataWithRemote(currentBranchPR, cwd, remote).catch(
       () => ({
         deployments: [],
         workflowRuns: [],
@@ -30875,7 +31194,6 @@ function createPRPoller(callbacks, log) {
       })
     );
     return {
-      taskId,
       prAvailable: true,
       currentBranchPR,
       assignedReviews: assigned.status === "fulfilled" ? assigned.value : [],
@@ -30886,81 +31204,135 @@ function createPRPoller(callbacks, log) {
       updatedAt: Date.now()
     };
   }
-  async function poll(taskId, entry) {
+  function pushToSubscribers(entry, payload) {
+    for (const taskId of entry.subscribers) {
+      callbacks.onPRState({ ...payload, taskId });
+    }
+  }
+  async function poll(topLevel, entry) {
+    if (entry.isPolling) return;
+    entry.isPolling = true;
     try {
-      const payload = await fetchPRState(taskId, entry.cwd);
+      const currentBranch = await run("git", ["rev-parse", "--abbrev-ref", "HEAD"], entry.cwd).then((s2) => s2.trim()).catch(() => "");
+      if (entry.lastBranch && currentBranch && currentBranch !== entry.lastBranch) {
+        entry.lastContent = "";
+        log.debug(
+          { topLevel, oldBranch: entry.lastBranch, newBranch: currentBranch },
+          "Branch changed, clearing dedup cache"
+        );
+      }
+      if (currentBranch) entry.lastBranch = currentBranch;
+      const payload = await fetchPRState(entry.cwd);
       if (!payload) return;
       const { updatedAt: _2, ...comparable } = payload;
       const contentKey = JSON.stringify(comparable);
       if (entry.lastContent === contentKey) {
-        log.debug({ taskId }, "PR state unchanged, skipping push");
+        log.debug({ topLevel }, "PR state unchanged, skipping push");
         return;
       }
       entry.lastContent = contentKey;
-      callbacks.onPRState(payload);
-      log.debug({ taskId, prAvailable: payload.prAvailable }, "PR state pushed");
+      entry.lastPayload = payload;
+      pushToSubscribers(entry, payload);
+      log.debug(
+        { topLevel, prAvailable: payload.prAvailable, subscribers: entry.subscribers.size },
+        "PR state pushed"
+      );
     } catch (err) {
-      log.warn({ err, taskId }, "PR poll failed");
+      log.warn({ err, topLevel }, "PR poll failed");
+    } finally {
+      entry.isPolling = false;
     }
   }
+  function removeFromPreviousRepo(taskId) {
+    const prev = taskToRepo.get(taskId);
+    if (!prev) return;
+    const prevEntry = repos.get(prev.topLevel);
+    if (prevEntry) {
+      prevEntry.subscribers.delete(taskId);
+      if (prevEntry.subscribers.size === 0) {
+        clearInterval(prevEntry.timer);
+        for (const t of prevEntry.burstTimers) clearTimeout(t);
+        repos.delete(prev.topLevel);
+        log.info({ topLevel: prev.topLevel }, "PR polling stopped (no subscribers)");
+      }
+    }
+    taskToRepo.delete(taskId);
+  }
   function startPolling(taskId, cwd) {
-    stopPolling(taskId);
-    const entry = {
-      timer: null,
-      burstTimers: [],
-      lastContent: "",
-      cwd
-    };
-    poll(taskId, entry).catch((err) => {
-      log.warn({ err, taskId }, "Initial PR poll failed");
-    });
-    entry.timer = setInterval(() => {
-      poll(taskId, entry).catch((err) => {
-        log.warn({ err, taskId }, "PR poll tick failed");
+    resolveTopLevel(cwd).then((topLevel) => {
+      if (disposed) return;
+      removeFromPreviousRepo(taskId);
+      taskToRepo.set(taskId, { topLevel, cwd });
+      const existing = repos.get(topLevel);
+      if (existing) {
+        existing.subscribers.add(taskId);
+        if (existing.lastPayload) {
+          callbacks.onPRState({ ...existing.lastPayload, taskId });
+        }
+        log.info({ taskId, topLevel, cwd }, "PR polling joined existing repo");
+        return;
+      }
+      const entry = {
+        timer: null,
+        burstTimers: [],
+        lastContent: "",
+        lastBranch: "",
+        lastPayload: null,
+        cwd,
+        subscribers: /* @__PURE__ */ new Set([taskId]),
+        isPolling: false
+      };
+      poll(topLevel, entry).catch((err) => {
+        log.warn({ err, topLevel }, "Initial PR poll failed");
       });
-    }, PR_POLL_INTERVAL_MS);
-    polls.set(taskId, entry);
-    log.info({ taskId, cwd }, "PR polling started");
+      entry.timer = setInterval(() => {
+        poll(topLevel, entry).catch((err) => {
+          log.warn({ err, topLevel }, "PR poll tick failed");
+        });
+      }, PR_POLL_INTERVAL_MS);
+      repos.set(topLevel, entry);
+      log.info({ taskId, topLevel, cwd }, "PR polling started");
+    }).catch((err) => {
+      log.warn({ err, taskId, cwd }, "Failed to resolve git toplevel for PR polling");
+    });
   }
   function getCwd(taskId) {
-    return polls.get(taskId)?.cwd ?? null;
+    return taskToRepo.get(taskId)?.cwd ?? null;
   }
   function stopPolling(taskId) {
-    const existing = polls.get(taskId);
-    if (existing) {
-      clearInterval(existing.timer);
-      for (const t of existing.burstTimers) clearTimeout(t);
-      polls.delete(taskId);
-      log.info({ taskId }, "PR polling stopped");
-    }
+    removeFromPreviousRepo(taskId);
   }
   function forceRefresh(taskId) {
-    const entry = polls.get(taskId);
+    const info = taskToRepo.get(taskId);
+    if (!info) return;
+    const entry = repos.get(info.topLevel);
     if (!entry) return;
     for (const t of entry.burstTimers) clearTimeout(t);
     entry.burstTimers = [];
     entry.lastContent = "";
-    poll(taskId, entry).catch((err) => {
-      log.warn({ err, taskId }, "PR force refresh failed");
+    poll(info.topLevel, entry).catch((err) => {
+      log.warn({ err, topLevel: info.topLevel }, "PR force refresh failed");
     });
     for (const delayMs of [3e3, 8e3, 15e3]) {
       entry.burstTimers.push(
         setTimeout(() => {
           entry.lastContent = "";
-          poll(taskId, entry).catch((err) => {
-            log.warn({ err, taskId }, "PR burst refresh failed");
+          poll(info.topLevel, entry).catch((err) => {
+            log.warn({ err, topLevel: info.topLevel }, "PR burst refresh failed");
           });
         }, delayMs)
       );
     }
   }
   function dispose() {
-    for (const [taskId, entry] of polls) {
+    disposed = true;
+    for (const [topLevel, entry] of repos) {
       clearInterval(entry.timer);
       for (const t of entry.burstTimers) clearTimeout(t);
-      log.debug({ taskId }, "PR poll timer cleared on dispose");
+      log.debug({ topLevel }, "PR poll timer cleared on dispose");
     }
-    polls.clear();
+    repos.clear();
+    taskToRepo.clear();
   }
   return { startPolling, stopPolling, forceRefresh, getCwd, dispose };
 }
@@ -31792,10 +32164,11 @@ async function rehydrateFromPersistence(persistence, taskManager, log, taskState
 async function sweepStaleTasks(taskStateStore, taskManager, log) {
   const tasks = await taskStateStore.listTasks();
   const actions = planStaleSweep(tasks, (id) => taskManager.isRunning(id));
+  const noBroadcast = { broadcast: false };
   for (const action of actions) {
     if (action.kind === "mark_input_required") {
-      await taskStateStore.updateTaskStatus(action.taskId, "input_required");
-      await taskStateStore.acknowledge(action.taskId);
+      await taskStateStore.updateTaskStatus(action.taskId, "input_required", noBroadcast);
+      await taskStateStore.acknowledge(action.taskId, noBroadcast);
       log({
         event: "stale_task_swept",
         taskId: action.taskId,
@@ -33797,7 +34170,7 @@ var TOOL_DESCRIPTION2 = [
   "The preview panel opens in the Shipyard UI next to the conversation. The user can interact with it directly."
 ].join("\n");
 var SetPreviewTargetInput = {
-  port: external_exports.number().int().positive().optional().describe("Local port number of the running dev server (e.g. 3000, 5173, 8080)."),
+  port: external_exports.number().int().min(1).max(65535).optional().describe("Local port number of the running dev server (e.g. 3000, 5173, 8080)."),
   url: external_exports.string().url().optional().describe('Fully qualified URL to preview (e.g. "http://localhost:3000/dashboard").')
 };
 function createPreviewTools(ctx) {
@@ -33818,9 +34191,14 @@ function createPreviewTools(ctx) {
             isError: true
           };
         }
-        await ctx.previewProxy.stop();
-        if (input.port != null && input.url == null) {
-          await ctx.previewProxy.start({ port: input.port });
+        if (input.url != null) {
+          await ctx.previewProxy.stop();
+        } else if (input.port != null) {
+          if (ctx.previewProxy.port) {
+            ctx.previewProxy.retarget(input.port);
+          } else {
+            await ctx.previewProxy.start({ port: input.port });
+          }
         }
         ctx.broadcastControl({
           type: "set_preview_target",
@@ -42788,6 +43166,16 @@ When you call ExitPlanMode, your plan is published to the Shipyard canvas for co
 **While in plan mode** \u2014 place supporting visualizations on the canvas using \`present(slug, "canvas")\`. Architecture diagrams, data models, and flow charts alongside the plan text help reviewers understand and evaluate your design.
 
 Do not revise the plan unless reviewers request changes. When you see \`<${XML_TAGS.PLAN_REVIEW} decision="approve">\`, call ExitPlanMode again to begin implementation.
+
+## Background Execution
+
+Prefer background execution to keep your main thread responsive to collaborators.
+
+**Agent tool** \u2014 Always use \`run_in_background: true\`. Foreground agents block your main thread \u2014 collaborators cannot interact with you, and there is no way to move a foreground operation to background after it starts. Background agents run in parallel and notify on completion.
+
+**Bash tool** \u2014 Use \`run_in_background: true\` for commands that may take more than 10 seconds: builds, installs, test suites, large git operations, network requests. Use \`TaskOutput\` to read results when notified. Keep short commands (git status, ls, cat) in the foreground.
+
+**Why this matters:** Foreground operations block everything. The only recovery from a stuck foreground operation is stopping the entire agent. Background-first execution avoids this and keeps you available for collaborator feedback.
 `.trim();
 function buildCollabSystemPrompt(participants) {
   const roster = participants.map((p2) => `${p2.name} (${p2.role})`).join(", ");
@@ -66428,11 +66816,13 @@ var AnthropicAgentSubprocess = class _AnthropicAgentSubprocess {
    * Guards all SDK write operations to prevent "ProcessTransport not ready" errors.
    */
   #closed = false;
-  constructor(query3, controller, onEvent, spawnMcpServers) {
+  #pidRef;
+  constructor(query3, controller, onEvent, spawnMcpServers, pidRef) {
     this.#query = query3;
     this.#controller = controller;
     this.#onEvent = onEvent;
     this.#spawnMcpServers = spawnMcpServers;
+    this.#pidRef = pidRef;
   }
   /** True once the subprocess has exited and SDK writes will throw. */
   get isClosed() {
@@ -66452,27 +66842,8 @@ var AnthropicAgentSubprocess = class _AnthropicAgentSubprocess {
     const controller = new InputController();
     const { onChildSpawned, onChildExited } = options;
     const stderrCallback = options.stderr;
-    const spawnClaudeCodeProcess = onChildSpawned ? (spawnOpts) => {
-      const child = spawn4(spawnOpts.command, spawnOpts.args, {
-        cwd: spawnOpts.cwd,
-        stdio: ["pipe", "pipe", stderrCallback ? "pipe" : "ignore"],
-        signal: spawnOpts.signal,
-        env: { ...spawnOpts.env, CLAUDECODE: void 0 },
-        windowsHide: true
-      });
-      if (!child.stdin || !child.stdout) {
-        throw new Error("Failed to create stdio pipes for Claude subprocess");
-      }
-      if (stderrCallback && child.stderr) {
-        child.stderr.on("data", (chunk) => stderrCallback(chunk.toString()));
-      }
-      if (child.pid) {
-        const pid = child.pid;
-        onChildSpawned(pid);
-        child.on("exit", () => onChildExited?.(pid));
-      }
-      return Object.assign(child, { stdin: child.stdin, stdout: child.stdout });
-    } : void 0;
+    const pidRef = { current: null };
+    const spawnClaudeCodeProcess = onChildSpawned ? createChildSpawner(stderrCallback, pidRef, onChildSpawned, onChildExited) : void 0;
     const queryInstance = queryFn({
       prompt: controller.iterable(),
       options: {
@@ -66503,7 +66874,8 @@ var AnthropicAgentSubprocess = class _AnthropicAgentSubprocess {
       queryInstance,
       controller,
       onEvent,
-      spawnMcpServers
+      spawnMcpServers,
+      pidRef
     );
     if (initialContent.length > 0) {
       controller.push(toSdkContent(initialContent));
@@ -66528,6 +66900,13 @@ var AnthropicAgentSubprocess = class _AnthropicAgentSubprocess {
     this.#query.close();
   }
   forceKill() {
+    if (this.#pidRef.current != null) {
+      try {
+        process.kill(this.#pidRef.current, "SIGKILL");
+      } catch {
+      }
+      this.#pidRef.current = null;
+    }
     this.#closed = true;
     this.#controller.end();
     this.#query.close();
@@ -66584,6 +66963,14 @@ var AnthropicAgentSubprocess = class _AnthropicAgentSubprocess {
       await this.#query.reconnectMcpServer(serverName);
     }
   }
+  async stopBackgroundTask(taskId) {
+    if (this.#closed) return;
+    try {
+      await this.#query.stopTask(taskId);
+    } catch (err) {
+      if (!this.#closed) throw err;
+    }
+  }
   async #runMessageLoop(log) {
     try {
       for await (const message of this.#query) {
@@ -66592,9 +66979,11 @@ var AnthropicAgentSubprocess = class _AnthropicAgentSubprocess {
           this.#onEvent(event);
         }
       }
+      this.#pidRef.current = null;
       this.#closed = true;
       this.#onEvent({ type: "subprocess_died" });
     } catch (error2) {
+      this.#pidRef.current = null;
       this.#closed = true;
       const errorMsg = error2 instanceof Error ? error2.message : String(error2);
       this.#onEvent({
@@ -66605,6 +66994,30 @@ var AnthropicAgentSubprocess = class _AnthropicAgentSubprocess {
     }
   }
 };
+function createChildSpawner(stderrCallback, pidRef, onChildSpawned, onChildExited) {
+  return (spawnOpts) => {
+    const child = spawn4(spawnOpts.command, spawnOpts.args, {
+      cwd: spawnOpts.cwd,
+      stdio: ["pipe", "pipe", stderrCallback ? "pipe" : "ignore"],
+      signal: spawnOpts.signal,
+      env: { ...spawnOpts.env, CLAUDECODE: void 0 },
+      windowsHide: true
+    });
+    if (!child.stdin || !child.stdout) {
+      throw new Error("Failed to create stdio pipes for Claude subprocess");
+    }
+    if (stderrCallback && child.stderr) {
+      child.stderr.on("data", (chunk) => stderrCallback(chunk.toString()));
+    }
+    if (child.pid) {
+      const pid = child.pid;
+      pidRef.current = pid;
+      onChildSpawned(pid);
+      child.on("exit", () => onChildExited?.(pid));
+    }
+    return Object.assign(child, { stdin: child.stdin, stdout: child.stdout });
+  };
+}
 function toSdkPermissionMode(mode) {
   switch (mode) {
     case "default":
@@ -72958,6 +73371,9 @@ var DirectApiSubprocess = class _DirectApiSubprocess {
   /** No-op: no MCP in direct API mode. */
   async reconnectMcpServer(_serverName) {
   }
+  /** No-op: direct API mode does not support background tasks. */
+  async stopBackgroundTask(_taskId) {
+  }
   /** No-op in Phase 1 -- harness task context not used by direct API mode. */
   setHarnessTaskId(_taskId) {
   }
@@ -75062,12 +75478,20 @@ function noop3(snapshot) {
   };
 }
 function handleColdIdle(snapshot, event) {
-  if (event.type !== "user_message") return noop3(snapshot);
-  const b2 = createEffectBuilder();
-  b2.log("cold_idle", "spawning", event.type);
-  b2.taskStatus("in_progress");
-  b2.effects.push({ type: "spawn", reason: { kind: "fresh" } });
-  return { state: "spawning", sessionId: null, rewindAtMessageId: null, effects: b2.effects };
+  if (event.type === "user_message") {
+    const b2 = createEffectBuilder();
+    b2.log("cold_idle", "spawning", event.type);
+    b2.taskStatus("in_progress");
+    b2.effects.push({ type: "spawn", reason: { kind: "fresh" } });
+    return { state: "spawning", sessionId: null, rewindAtMessageId: null, effects: b2.effects };
+  }
+  if (event.type === "stop_commanded") {
+    const b2 = createEffectBuilder();
+    b2.effects.push({ type: "clear_queue" });
+    b2.taskStatus("input_required");
+    return { state: "cold_idle", sessionId: null, rewindAtMessageId: null, effects: b2.effects };
+  }
+  return noop3(snapshot);
 }
 function handleResumableIdle(snapshot, event) {
   const { sessionId, rewindAtMessageId } = snapshot;
@@ -75086,6 +75510,12 @@ function handleResumableIdle(snapshot, event) {
     b2.effects.push({ type: "spawn", reason });
     return { state: "spawning", sessionId, rewindAtMessageId: null, effects: b2.effects };
   }
+  if (event.type === "stop_commanded") {
+    const b2 = createEffectBuilder();
+    b2.effects.push({ type: "clear_queue" });
+    b2.taskStatus("input_required");
+    return { state: "resumable_idle", sessionId, rewindAtMessageId, effects: b2.effects };
+  }
   if (event.type === "session_expired") {
     const b2 = createEffectBuilder();
     b2.log("resumable_idle", "cold_idle", event.type);
@@ -75245,12 +75675,7 @@ function exitStoppingAlive(snapshot, trigger) {
   const { sessionId, rewindAtMessageId } = snapshot;
   const b2 = createEffectBuilder();
   b2.effects.push({ type: "clear_pending_inputs" });
-  if (snapshot.queueDepth > 0) {
-    b2.log("stopping", "running", trigger);
-    b2.effects.push({ type: "push_message" });
-    b2.taskStatus("in_progress");
-    return { state: "running", sessionId, rewindAtMessageId, effects: b2.effects };
-  }
+  b2.effects.push({ type: "clear_queue" });
   b2.log("stopping", "warm_idle", trigger);
   b2.taskStatus("input_required");
   return { state: "warm_idle", sessionId, rewindAtMessageId, effects: b2.effects };
@@ -75278,7 +75703,7 @@ function handleStopping(snapshot, event) {
     b2.taskStatus("input_required");
     return { state: "resumable_idle", sessionId, rewindAtMessageId, effects: b2.effects };
   }
-  if (event.type === "stop_timeout") {
+  if (event.type === "stop_timeout" || event.type === "interrupt_failed") {
     b2.log("stopping", "resumable_idle", event.type);
     b2.effects.push({ type: "force_kill" });
     b2.effects.push({ type: "clear_pending_inputs" });
@@ -75367,6 +75792,9 @@ var AgentSessionManager = class {
   notifyInterruptAcknowledged() {
     this.#dispatch({ type: "interrupt_acknowledged" });
   }
+  notifyInterruptFailed() {
+    this.#dispatch({ type: "interrupt_failed" });
+  }
   notifyCloseAcknowledged() {
     this.#dispatch({ type: "close_acknowledged" });
   }
@@ -75868,6 +76296,10 @@ var Thread = class {
     if (!this.#subprocess) return;
     return this.#subprocess.mcpSubmitOAuthCallbackUrl(serverName, callbackUrl);
   }
+  async stopBackgroundTask(taskId) {
+    if (!this.#subprocess) return;
+    await this.#subprocess.stopBackgroundTask(taskId);
+  }
   async dispose() {
     this.#disposed = true;
     this.#permissionHandler.denyAllPending("Thread disposed");
@@ -76158,13 +76590,18 @@ ${conversationReplay}` : conversationReplay;
     this.#subprocess?.pushMessage(content);
   }
   #handleInterrupt() {
-    this.#subprocess?.interrupt().catch((err) => {
+    if (!this.#subprocess || this.#subprocess.isClosed) {
+      this.#manager.notifySubprocessDied();
+      return;
+    }
+    this.#subprocess.interrupt().catch((err) => {
       const msg = err instanceof Error ? err.message : String(err);
       this.#config.log({
         event: "thread_interrupt_failed",
         threadId: this.#config.threadId,
         error: msg
       });
+      this.#manager.notifyInterruptFailed();
     });
   }
   #handleClose() {
@@ -81061,6 +81498,9 @@ var Task = class _Task {
     this.#explicitlyStopped = true;
     this.#mainThread.stop();
   }
+  async stopBackgroundTask(backgroundTaskId) {
+    await this.#mainThread.stopBackgroundTask(backgroundTaskId);
+  }
   cancelQueued() {
     const count = this.#mainThread.cancelQueued();
     const collabCount = this.#collabQueue.cancelQueued();
@@ -82081,6 +82521,122 @@ Use this context to maintain continuity. You have already done this work \u2014
   }
 };
 
+// src/services/task/task-manager-mcp.ts
+function hasLiveSubprocess(state) {
+  return state === "warm_idle" || state === "running" || state === "spawning";
+}
+function updateMcpServers(tasks, deps) {
+  const resolved = deps.resolveMcpServers() ?? {};
+  for (const task of tasks.values()) {
+    if (!hasLiveSubprocess(task.orchestrator.state)) continue;
+    task.orchestrator.setMcpServers(resolved).then((result) => {
+      deps.log({
+        event: "mcp_servers_updated",
+        taskId: task.taskId,
+        added: result?.added ?? [],
+        removed: result?.removed ?? [],
+        errors: result?.errors ?? {}
+      });
+    }).catch((err) => {
+      deps.log({
+        event: "mcp_servers_update_failed",
+        taskId: task.taskId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
+  }
+}
+function triggerFastMcpPolling(tasks) {
+  for (const task of tasks.values()) {
+    if (!hasLiveSubprocess(task.orchestrator.state)) continue;
+    task.orchestrator.triggerFastMcpPolling();
+  }
+}
+function toggleMcpServer(tasks, serverName, enabled, log) {
+  for (const task of tasks.values()) {
+    if (!hasLiveSubprocess(task.orchestrator.state)) continue;
+    task.orchestrator.toggleMcpServer(serverName, enabled).then(() => {
+      log({
+        event: "mcp_server_toggled",
+        taskId: task.taskId,
+        serverName,
+        enabled
+      });
+    }).catch((err) => {
+      log({
+        event: "mcp_server_toggle_failed",
+        taskId: task.taskId,
+        serverName,
+        enabled,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
+  }
+}
+function reconnectMcpServer(tasks, serverName, deps) {
+  const fullSet = deps.resolveMcpServers() ?? {};
+  for (const task of tasks.values()) {
+    if (!hasLiveSubprocess(task.orchestrator.state)) continue;
+    const withoutTarget = { ...fullSet };
+    delete withoutTarget[serverName];
+    task.orchestrator.setMcpServers(withoutTarget).then(() => task.orchestrator.setMcpServers(fullSet)).then((result) => {
+      deps.log({
+        event: "mcp_server_reconnected",
+        taskId: task.taskId,
+        serverName,
+        added: result?.added ?? [],
+        removed: result?.removed ?? []
+      });
+    }).catch((err) => {
+      deps.log({
+        event: "mcp_server_reconnect_failed",
+        taskId: task.taskId,
+        serverName,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
+  }
+}
+async function mcpAuthenticate(tasks, serverName) {
+  for (const task of tasks.values()) {
+    if (!hasLiveSubprocess(task.orchestrator.state)) continue;
+    return task.orchestrator.mcpAuthenticate(serverName);
+  }
+  return null;
+}
+async function mcpSubmitOAuthCallbackUrl(tasks, serverName, callbackUrl) {
+  for (const task of tasks.values()) {
+    if (!hasLiveSubprocess(task.orchestrator.state)) continue;
+    await task.orchestrator.mcpSubmitOAuthCallbackUrl(serverName, callbackUrl);
+    return;
+  }
+}
+function planGracefulShutdown(tasks, gracePeriodMs) {
+  const immediate = [];
+  const deferred = [];
+  for (const task of tasks) {
+    switch (task.state) {
+      case "cold_idle":
+      case "resumable_idle":
+      case "warm_idle":
+        immediate.push({ taskId: task.taskId, kind: "dispose_immediately" });
+        break;
+      case "spawning":
+      case "running":
+        deferred.push({ taskId: task.taskId, kind: "stop_then_wait" });
+        break;
+      case "stopping":
+        deferred.push({ taskId: task.taskId, kind: "stop_then_wait" });
+        break;
+      default: {
+        const _exhaustive = task.state;
+        throw new Error(`Unhandled state: ${JSON.stringify(_exhaustive)}`);
+      }
+    }
+  }
+  return { immediate, deferred, gracePeriodMs };
+}
+
 // src/services/task/task-manager.ts
 function cloneOverlay(overlay) {
   return {
@@ -82605,111 +83161,32 @@ var TaskManager = class {
     this.#deps.log({ event: "task_stop_requested", taskId });
     this.#tasks.get(taskId)?.orchestrator.stop();
   }
-  /**
-   * Hot-update MCP servers on all live subprocesses. Since user/plugin
-   * MCPs are added via the dynamic pool (setMcpServers after init),
-   * they can be freely added and removed without subprocess restart.
-   */
-  updateMcpServers() {
-    const resolved = this.#deps.resolveMcpServers() ?? {};
-    for (const task of this.#tasks.values()) {
-      if (!this.#hasLiveSubprocess(task.orchestrator.state)) continue;
-      task.orchestrator.setMcpServers(resolved).then((result) => {
-        this.#deps.log({
-          event: "mcp_servers_updated",
-          taskId: task.taskId,
-          added: result?.added ?? [],
-          removed: result?.removed ?? [],
-          errors: result?.errors ?? {}
-        });
-      }).catch((err) => {
-        this.#deps.log({
-          event: "mcp_servers_update_failed",
-          taskId: task.taskId,
-          error: err instanceof Error ? err.message : String(err)
-        });
-      });
+  async stopBackgroundTask(taskId, backgroundTaskId) {
+    this.#deps.log({ event: "background_task_stop_requested", taskId, backgroundTaskId });
+    const task = this.#tasks.get(taskId);
+    if (!task) {
+      this.#deps.log({ event: "background_task_stop_unknown_task", taskId, backgroundTaskId });
+      return;
     }
+    await task.orchestrator.stopBackgroundTask(backgroundTaskId);
+  }
+  updateMcpServers() {
+    updateMcpServers(this.#tasks, this.#deps);
   }
   triggerFastMcpPolling() {
-    for (const task of this.#tasks.values()) {
-      if (!this.#hasLiveSubprocess(task.orchestrator.state)) continue;
-      task.orchestrator.triggerFastMcpPolling();
-    }
+    triggerFastMcpPolling(this.#tasks);
   }
   toggleMcpServer(serverName, enabled) {
-    for (const task of this.#tasks.values()) {
-      if (!this.#hasLiveSubprocess(task.orchestrator.state)) continue;
-      task.orchestrator.toggleMcpServer(serverName, enabled).then(() => {
-        this.#deps.log({
-          event: "mcp_server_toggled",
-          taskId: task.taskId,
-          serverName,
-          enabled
-        });
-      }).catch((err) => {
-        this.#deps.log({
-          event: "mcp_server_toggle_failed",
-          taskId: task.taskId,
-          serverName,
-          enabled,
-          error: err instanceof Error ? err.message : String(err)
-        });
-      });
-    }
+    toggleMcpServer(this.#tasks, serverName, enabled, this.#deps.log);
   }
-  /**
-   * Force reconnect a specific MCP server after token refresh.
-   *
-   * The SDK subprocess diffs setMcpServers by name: if the server name
-   * already exists it is NOT reconnected even when headers change. To
-   * pick up fresh credentials we remove the server first, then re-add it.
-   */
   reconnectMcpServer(serverName) {
-    const fullSet = this.#deps.resolveMcpServers() ?? {};
-    for (const task of this.#tasks.values()) {
-      if (!this.#hasLiveSubprocess(task.orchestrator.state)) continue;
-      const withoutTarget = { ...fullSet };
-      delete withoutTarget[serverName];
-      task.orchestrator.setMcpServers(withoutTarget).then(() => task.orchestrator.setMcpServers(fullSet)).then((result) => {
-        this.#deps.log({
-          event: "mcp_server_reconnected",
-          taskId: task.taskId,
-          serverName,
-          added: result?.added ?? [],
-          removed: result?.removed ?? []
-        });
-      }).catch((err) => {
-        this.#deps.log({
-          event: "mcp_server_reconnect_failed",
-          taskId: task.taskId,
-          serverName,
-          error: err instanceof Error ? err.message : String(err)
-        });
-      });
-    }
+    reconnectMcpServer(this.#tasks, serverName, this.#deps);
   }
-  /**
-   * Initiate SDK-level OAuth for an MCP server on any active task.
-   * Returns the authorize URL if the SDK supports it, null otherwise.
-   */
   async mcpAuthenticate(serverName) {
-    for (const task of this.#tasks.values()) {
-      if (!this.#hasLiveSubprocess(task.orchestrator.state)) continue;
-      return task.orchestrator.mcpAuthenticate(serverName);
-    }
-    return null;
+    return mcpAuthenticate(this.#tasks, serverName);
   }
   async mcpSubmitOAuthCallbackUrl(serverName, callbackUrl) {
-    for (const task of this.#tasks.values()) {
-      if (!this.#hasLiveSubprocess(task.orchestrator.state)) continue;
-      await task.orchestrator.mcpSubmitOAuthCallbackUrl(serverName, callbackUrl);
-      return;
-    }
-  }
-  /** True when the state implies a subprocess is alive and can accept commands. */
-  #hasLiveSubprocess(state) {
-    return state === "warm_idle" || state === "running" || state === "spawning";
+    return mcpSubmitOAuthCallbackUrl(this.#tasks, serverName, callbackUrl);
   }
   cancelQueued(taskId) {
     const task = this.#tasks.get(taskId);
@@ -82886,7 +83363,7 @@ var TaskManager = class {
   /** Whether any task has a live subprocess that can accept MCP commands. */
   get hasLiveSubprocesses() {
     for (const task of this.#tasks.values()) {
-      if (this.#hasLiveSubprocess(task.orchestrator.state)) return true;
+      if (hasLiveSubprocess(task.orchestrator.state)) return true;
     }
     return false;
   }
@@ -83016,31 +83493,6 @@ var TaskManager = class {
     });
   }
 };
-function planGracefulShutdown(tasks, gracePeriodMs) {
-  const immediate = [];
-  const deferred = [];
-  for (const task of tasks) {
-    switch (task.state) {
-      case "cold_idle":
-      case "resumable_idle":
-      case "warm_idle":
-        immediate.push({ taskId: task.taskId, kind: "dispose_immediately" });
-        break;
-      case "spawning":
-      case "running":
-        deferred.push({ taskId: task.taskId, kind: "stop_then_wait" });
-        break;
-      case "stopping":
-        deferred.push({ taskId: task.taskId, kind: "stop_then_wait" });
-        break;
-      default: {
-        const _exhaustive = task.state;
-        throw new Error(`Unhandled state: ${JSON.stringify(_exhaustive)}`);
-      }
-    }
-  }
-  return { immediate, deferred, gracePeriodMs };
-}
 
 // src/services/task/task-state-store.ts
 import { join as join35 } from "path";
@@ -83072,12 +83524,43 @@ function buildTaskStateStore(dataDir) {
   const unsubVersion = store.subscribe(() => {
     _version++;
   });
+  const _broadcastQueue = [];
+  const taskListeners = /* @__PURE__ */ new Set();
+  const unsubBroadcast = store.subscribe((event) => {
+    const broadcast = _broadcastQueue.shift() ?? true;
+    const augmented = { ...event, broadcast };
+    for (const listener of taskListeners) {
+      try {
+        listener(augmented);
+      } catch {
+      }
+    }
+  });
+  function pushBroadcast(options) {
+    _broadcastQueue.push(options?.broadcast ?? true);
+  }
+  async function safeUpdate(taskId, fn, options) {
+    pushBroadcast(options);
+    const lenBefore = _broadcastQueue.length;
+    try {
+      await store.update(taskId, fn);
+    } catch (err) {
+      if (_broadcastQueue.length === lenBefore) {
+        _broadcastQueue.pop();
+      }
+      throw err;
+    }
+    if (_broadcastQueue.length === lenBefore) {
+      _broadcastQueue.pop();
+    }
+  }
   return {
     get version() {
       return _version;
     },
-    async createTask({ taskId, channelId, title, cwd, mode, scheduleId, scheduleName }) {
+    async createTask({ taskId, channelId, title, cwd, mode, scheduleId, scheduleName }, options) {
       const now = Date.now();
+      pushBroadcast(options);
       await store.set(taskId, {
         taskId,
         channelId,
@@ -83097,41 +83580,46 @@ function buildTaskStateStore(dataDir) {
         ...scheduleName ? { scheduleName } : {}
       });
     },
-    async updateTaskStatus(taskId, status) {
+    async updateTaskStatus(taskId, status, options) {
       const task = await store.get(taskId);
       if (!task) return;
+      pushBroadcast(options);
       await store.set(taskId, applyStatusTransition(task, status, Date.now()));
     },
-    async updateTitle(taskId, title) {
+    async updateTitle(taskId, title, options) {
       const task = await store.get(taskId);
       if (!task) return;
+      pushBroadcast(options);
       await store.set(taskId, {
         ...task,
         title,
         updatedAt: Date.now()
       });
     },
-    async updateCwd(taskId, cwd) {
+    async updateCwd(taskId, cwd, options) {
       const task = await store.get(taskId);
       if (!task) return;
+      pushBroadcast(options);
       await store.set(taskId, {
         ...task,
         cwd,
         updatedAt: Date.now()
       });
     },
-    async updateMode(taskId, mode) {
+    async updateMode(taskId, mode, options) {
       const task = await store.get(taskId);
       if (!task) return;
+      pushBroadcast(options);
       await store.set(taskId, {
         ...task,
         mode,
         updatedAt: Date.now()
       });
     },
-    async updateTodoProgress(taskId, progress) {
+    async updateTodoProgress(taskId, progress, options) {
       const task = await store.get(taskId);
       if (!task) return;
+      pushBroadcast(options);
       await store.set(taskId, {
         ...task,
         todoCompleted: progress.todoCompleted,
@@ -83140,15 +83628,16 @@ function buildTaskStateStore(dataDir) {
         updatedAt: Date.now()
       });
     },
-    async acknowledge(taskId) {
-      await store.update(taskId, (task) => ({ ...task, acknowledgedAt: Date.now() }));
+    async acknowledge(taskId, options) {
+      await safeUpdate(taskId, (task) => ({ ...task, acknowledgedAt: Date.now() }), options);
     },
-    async togglePin(taskId) {
-      await store.update(taskId, (task) => ({ ...task, pinned: !task.pinned }));
+    async togglePin(taskId, options) {
+      await safeUpdate(taskId, (task) => ({ ...task, pinned: !task.pinned }), options);
     },
-    async updateStructuredTasks(taskId, tasks, todoProgress) {
+    async updateStructuredTasks(taskId, tasks, todoProgress, options) {
       const task = await store.get(taskId);
       if (!task) return;
+      pushBroadcast(options);
       await store.set(taskId, {
         ...task,
         structuredTasks: tasks,
@@ -83160,39 +83649,49 @@ function buildTaskStateStore(dataDir) {
         updatedAt: Date.now()
       });
     },
-    async updateTaskOverlay(taskId, overlay) {
+    async updateTaskOverlay(taskId, overlay, options) {
       const task = await store.get(taskId);
       if (!task) return;
+      pushBroadcast(options);
       await store.set(taskId, {
         ...task,
         taskOverlay: overlay,
         updatedAt: Date.now()
       });
     },
-    async updateComposerSettings(taskId, settings) {
+    async updateComposerSettings(taskId, settings, options) {
       const task = await store.get(taskId);
       if (!task) return;
+      pushBroadcast(options);
       await store.set(taskId, {
         ...task,
         composerSettings: { ...task.composerSettings, ...settings },
         updatedAt: Date.now()
       });
     },
-    async updateCostStats(taskId, stats) {
-      await store.update(taskId, (task) => ({
-        ...task,
-        totalCostUsd: stats.totalCostUsd,
-        totalOutputTokens: stats.totalOutputTokens,
-        updatedAt: Date.now()
-      }));
+    async updateCostStats(taskId, stats, options) {
+      await safeUpdate(
+        taskId,
+        (task) => ({
+          ...task,
+          totalCostUsd: stats.totalCostUsd,
+          totalOutputTokens: stats.totalOutputTokens,
+          updatedAt: Date.now()
+        }),
+        options
+      );
     },
-    async clearCostStats(taskId) {
-      await store.update(taskId, (task) => ({
-        ...task,
-        totalCostUsd: 0,
-        totalOutputTokens: 0,
-        updatedAt: Date.now()
-      }));
+    async clearCostStats(taskId, options) {
+      await safeUpdate(
+        taskId,
+        (task) => ({
+          ...task,
+          totalCostUsd: 0,
+          totalOutputTokens: 0,
+          updatedAt: Date.now()
+        }),
+        options
+      );
     },
     async getTask(taskId) {
       return store.get(taskId);
@@ -83201,10 +83700,14 @@ function buildTaskStateStore(dataDir) {
       return store.list();
     },
     subscribe(listener) {
-      return store.subscribe(listener);
+      taskListeners.add(listener);
+      return () => {
+        taskListeners.delete(listener);
+      };
     },
     dispose() {
       unsubVersion();
+      unsubBroadcast();
     }
   };
 }
@@ -83963,6 +84466,7 @@ async function createDaemon(deps) {
   await rehydrateFromPersistence(sessionPersistence, taskManager, deps.log, taskStateStore);
   await sweepStaleTasks(taskStateStore, taskManager, deps.log);
   const taskStoreUnsub = taskStateStore.subscribe((event) => {
+    if (!event.broadcast) return;
     switch (event.kind) {
       case "set": {
         taskManager.broadcastControl({
@@ -84311,10 +84815,12 @@ var ROLE_PERMISSIONS = {
     "list_schedules",
     "run_schedule_now",
     "stop_task",
+    "request_preview_target",
     "todo_item_added",
     "todo_item_removed",
     "todo_item_updated",
-    "todo_dep_changed"
+    "todo_dep_changed",
+    "presence_update"
   ]),
   "collaborator-full": /* @__PURE__ */ new Set([
     "send_message",
@@ -84341,10 +84847,12 @@ var ROLE_PERMISSIONS = {
     "request_annotation_snapshot",
     "create_thread",
     "list_threads",
+    "request_preview_target",
     "todo_item_added",
     "todo_item_removed",
     "todo_item_updated",
-    "todo_dep_changed"
+    "todo_dep_changed",
+    "presence_update"
   ]),
   "collaborator-review": /* @__PURE__ */ new Set([
     "stop",
@@ -84355,7 +84863,8 @@ var ROLE_PERMISSIONS = {
     "join_collab_room",
     "leave_collab_room",
     "request_annotation_snapshot",
-    "list_threads"
+    "list_threads",
+    "presence_update"
   ]),
   viewer: /* @__PURE__ */ new Set([
     "subscribe",
@@ -84363,7 +84872,8 @@ var ROLE_PERMISSIONS = {
     "request_capabilities",
     "request_pr_data",
     "join_collab_room",
-    "leave_collab_room"
+    "leave_collab_room",
+    "presence_update"
   ])
 };
 function isCollabActionAllowed(role, action) {
@@ -84536,6 +85046,7 @@ function filterOutboundForCollab(msg, collabTaskId) {
     case "worktree_error":
     case "worktree_list":
     case "worktree_removed":
+    case "directory_list":
     case "collab_room_joined":
     case "collab_room_left":
     case "schedule_fired":
@@ -84572,11 +85083,15 @@ function filterOutboundForCollab(msg, collabTaskId) {
     /** Collab-scoped: always pass through (keyed by machineId/roomId, not taskId) */
     case "collab_peer_role":
     case "collab_participants_update":
+    case "presence_state":
       return msg;
     /** Pass through: collab peers need error feedback */
     case "promote_nudge":
     case "error":
       return msg;
+    /** Log request is local-only, not relevant for collab peers */
+    case "recent_logs":
+      return null;
     /** Exhaustiveness check: compile error if a new type is unhandled */
     default: {
       const _exhaustive = msg;
@@ -84851,6 +85366,9 @@ function routeMessage(msg, callbacks, log) {
     case "request_user_settings":
       callbacks.onRequestUserSettings();
       break;
+    case "request_preview_target":
+      callbacks.onRequestPreviewTarget(msg.port, msg.url);
+      break;
     /** Unified annotation CRUD */
     case "add_annotation":
       callbacks.onAddAnnotation(msg.taskId, msg.annotation);
@@ -84931,6 +85449,9 @@ function routeMessage(msg, callbacks, log) {
     case "stop_task":
       callbacks.onStopTask(msg.taskId);
       break;
+    case "stop_background_agent":
+      callbacks.onStopBackgroundAgent(msg.taskId, msg.backgroundTaskId);
+      break;
     case "todo_item_added":
       callbacks.onTodoItemAdded(msg.taskId, msg.item);
       break;
@@ -84950,6 +85471,15 @@ function routeMessage(msg, callbacks, log) {
         msg.action
       );
       break;
+    case "request_recent_logs":
+      callbacks.onRequestRecentLogs(msg.windowMinutes);
+      break;
+    case "presence_update":
+      callbacks.onPresenceUpdate(msg.state);
+      break;
+    case "list_directories":
+      callbacks.onListDirectories(msg.basePath);
+      break;
     default: {
       const _exhaustive = msg;
       throw new Error(`Unhandled control message type: ${JSON.stringify(_exhaustive)}`);
@@ -84991,6 +85521,7 @@ function injectThreadResourceLink(store, mainChannelId, taskId, threadId, title,
 
 // src/services/channels/control-channel-infra-handlers.ts
 import { spawn as spawn6 } from "child_process";
+import { readdir as readdir7 } from "fs/promises";
 
 // src/services/worktree-service.ts
 import { execFile as execFile7, spawn as spawn5 } from "child_process";
@@ -85482,6 +86013,24 @@ function buildAgentInstallHandlers(deps) {
     }
   };
 }
+var FILTERED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".turbo", "dist", ".next", "build"]);
+function buildDirectoryListHandler(deps) {
+  return {
+    onListDirectories: (basePath) => {
+      readdir7(basePath, { withFileTypes: true }).then((entries) => {
+        const directories = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && !FILTERED_DIRS.has(e.name)).map((e) => e.name).sort();
+        deps.sendControlMessage({ type: "directory_list", basePath, directories });
+      }).catch((err) => {
+        deps.logAdapter({
+          event: "list_directories_failed",
+          basePath,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        deps.sendControlMessage({ type: "directory_list", basePath, directories: [] });
+      });
+    }
+  };
+}
 function buildEnvironmentChangedHandler(deps) {
   const { daemon } = deps;
   let debounceTimer = null;
@@ -85715,6 +86264,99 @@ function runPluginOp(pluginName, marketplace, action, ctx) {
   });
 }
 
+// src/services/channels/read-recent-logs.ts
+import { createReadStream, readdirSync as readdirSync2 } from "fs";
+import { join as join38 } from "path";
+import { createInterface } from "readline";
+var MAX_BYTES = 5e4;
+var LOG_BASE_NAME = "daemon.log";
+var SENSITIVE_PATTERNS = [
+  [/eyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*/g, "[REDACTED_JWT]"],
+  [/"[Aa]uthorization"\s*:\s*"[^"]+"/g, '"Authorization":"[REDACTED]"'],
+  [/"token"\s*:\s*"[^"]+"/g, '"token":"[REDACTED]"'],
+  [/"accessToken"\s*:\s*"[^"]+"/g, '"accessToken":"[REDACTED]"'],
+  [/"refreshToken"\s*:\s*"[^"]+"/g, '"refreshToken":"[REDACTED]"'],
+  [/sk-ant-[A-Za-z0-9_-]{20,}/g, "[REDACTED_API_KEY]"],
+  [/sk-[a-zA-Z0-9]{20,}/g, "[REDACTED_SECRET_KEY]"],
+  [/device_code=[A-Za-z0-9_-]+/g, "device_code=[REDACTED]"]
+];
+function scrubSensitiveData(line) {
+  let result = line;
+  for (const [pattern, replacement] of SENSITIVE_PATTERNS) {
+    result = result.replace(pattern, replacement);
+  }
+  return result;
+}
+async function collectFromFile(filePath, cutoff, collector, maxBytes) {
+  const rl = createInterface({
+    input: createReadStream(filePath, { encoding: "utf-8" }),
+    crlfDelay: Number.POSITIVE_INFINITY
+  });
+  for await (const line of rl) {
+    if (!line) continue;
+    const timestamp = extractTimestamp(line);
+    if (timestamp === null || timestamp < cutoff) continue;
+    const scrubbed = scrubSensitiveData(line);
+    const lineBytes = Buffer.byteLength(scrubbed, "utf-8");
+    if (collector.totalBytes + lineBytes > maxBytes) {
+      collector.truncated = true;
+      rl.close();
+      return true;
+    }
+    collector.lines.push(scrubbed);
+    collector.totalBytes += lineBytes;
+  }
+  return false;
+}
+async function readRecentLogs(logDir, windowMinutes, maxBytes = MAX_BYTES) {
+  const cutoff = Date.now() - windowMinutes * 6e4;
+  const collector = { lines: [], totalBytes: 0, truncated: false };
+  for (const filePath of discoverLogFiles(logDir)) {
+    try {
+      const exhausted = await collectFromFile(filePath, cutoff, collector, maxBytes);
+      if (exhausted) break;
+    } catch {
+    }
+  }
+  return { lines: collector.lines, truncated: collector.truncated };
+}
+function discoverLogFiles(logDir) {
+  let entries;
+  try {
+    entries = readdirSync2(logDir);
+  } catch {
+    return [];
+  }
+  const rotated = [];
+  let currentFile = null;
+  for (const entry of entries) {
+    if (entry === LOG_BASE_NAME) {
+      currentFile = join38(logDir, entry);
+    } else if (entry.startsWith(`${LOG_BASE_NAME}.`)) {
+      const suffix = entry.slice(LOG_BASE_NAME.length + 1);
+      const index = Number.parseInt(suffix, 10);
+      if (!Number.isNaN(index)) {
+        rotated.push({ path: join38(logDir, entry), index });
+      }
+    }
+  }
+  rotated.sort((a, b2) => b2.index - a.index);
+  const result = rotated.map((r) => r.path);
+  if (currentFile) result.push(currentFile);
+  return result;
+}
+function extractTimestamp(line) {
+  const idx = line.indexOf('"time":');
+  if (idx === -1) return null;
+  const start = idx + 7;
+  let end = start;
+  while (end < line.length && line.charCodeAt(end) >= 48 && line.charCodeAt(end) <= 57) {
+    end++;
+  }
+  if (end === start) return null;
+  return Number(line.slice(start, end));
+}
+
 // src/services/channels/schedule-channel-callbacks.ts
 function buildScheduleCallbacks(daemon, getControlHandler, log) {
   return {
@@ -85883,6 +86525,33 @@ function buildTemplateCallbacks(daemon, getControlHandler, log) {
 }
 
 // src/services/channels/control-channel-wiring.ts
+function handlePreviewTargetRequest(proxy, port, url, daemon, log) {
+  if (!proxy) return;
+  (async () => {
+    try {
+      if (url) await proxy.stop();
+      else if (port) proxy.port ? proxy.retarget(port) : await proxy.start({ port });
+      daemon.taskManager.broadcastControl({
+        type: "set_preview_target",
+        port,
+        url,
+        proxyPort: proxy.port ?? void 0
+      });
+    } catch (err) {
+      log({
+        event: "preview_target_request_failed",
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  })();
+}
+function resolveIdentityFromRegistry(deps) {
+  if (!deps.peerRoleRegistry || !deps.peerMachineId) return void 0;
+  const entry = deps.peerRoleRegistry.getEntry(deps.peerMachineId);
+  if (!entry) return void 0;
+  const userId = entry.participantId.replace(/^human:/, "");
+  return { userId, username: entry.displayName, avatarUrl: null };
+}
 function applyMcpServerToggles(daemon, prevDisabled, nextDisabled, log) {
   for (const name of nextDisabled) {
     if (!prevDisabled.has(name)) {
@@ -85978,6 +86647,10 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
   const worktreeHandlers = buildWorktreeHandlers(lazyInfraDeps);
   const agentInstallHandlers = buildAgentInstallHandlers(lazyInfraDeps);
   const envChangedHandler = buildEnvironmentChangedHandler(lazyInfraDeps);
+  const directoryListHandler = buildDirectoryListHandler({
+    sendControlMessage: (msg) => controlHandler.sendControl(msg),
+    logAdapter
+  });
   const prPoller = createPRPoller(
     {
       onPRState: (payload) => {
@@ -86241,6 +86914,7 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
       },
       ...agentInstallHandlers,
       ...worktreeHandlers,
+      ...directoryListHandler,
       onJoinCollabRoom: (() => {
         const mgr = deps?.collabRoomManager;
         if (!mgr) return void 0;
@@ -86545,6 +87219,9 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
           });
         });
       },
+      onRequestPreviewTarget: (port, url) => {
+        handlePreviewTargetRequest(deps?.previewProxy, port, url, daemon, logAdapter);
+      },
       onAcknowledgeTask: (taskId) => {
         daemon.taskStateStore.acknowledge(taskId).catch((err) => {
           logAdapter({
@@ -86574,9 +87251,44 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
           });
         }
       },
+      onStopBackgroundAgent: (taskId, backgroundTaskId) => {
+        daemon.taskManager.stopBackgroundTask(taskId, backgroundTaskId).catch((err) => {
+          logAdapter({
+            event: "stop_background_agent_failed",
+            taskId,
+            backgroundTaskId,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+      },
       ...buildScheduleCallbacks(daemon, () => controlHandler, logAdapter),
       ...buildTemplateCallbacks(daemon, () => controlHandler, logAdapter),
-      ...todoHandlers
+      ...todoHandlers,
+      onRequestRecentLogs: (windowMinutes) => {
+        const logDir = `${deps?.shipyardHome ?? getShipyardHome()}/logs`;
+        readRecentLogs(logDir, windowMinutes).then((result) => {
+          handler.sendControl({ type: "recent_logs", ...result });
+          logAdapter({
+            event: "recent_logs_sent",
+            lineCount: result.lines.length,
+            truncated: result.truncated
+          });
+        }).catch((err) => {
+          handler.sendControl({ type: "recent_logs", lines: [], truncated: false });
+          logAdapter({
+            event: "recent_logs_failed",
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+      },
+      onPresenceUpdate: (state) => {
+        if (!deps?.presencePool) return;
+        const identity = deps.peerIdentity ?? resolveIdentityFromRegistry(deps);
+        if (!identity) return;
+        const ref = deps.presencePool;
+        ref.pool = applyPresenceUpdate(ref.pool, controlPeerId, identity, state);
+        daemon.taskManager.broadcastControl({ type: "presence_state", peers: ref.pool });
+      }
     },
     logAdapter
   );
@@ -86699,6 +87411,9 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
   const userSettingsUnsub = daemon.userSettingsStore.subscribe((settings) => {
     controlHandler.sendControl({ type: "user_settings_updated", settings });
   });
+  if (deps?.presencePool) {
+    controlHandler.sendControl({ type: "presence_state", peers: deps.presencePool.pool });
+  }
   const enforcedTaskId = deps?.collabTaskId;
   dc.onmessage = (ev) => {
     const raw = typeof ev.data === "string" ? ev.data : String(ev.data);
@@ -86725,6 +87440,11 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
     handler.dispose();
     daemon.taskManager.unregisterControlChannel(controlPeerId);
     daemon.taskManager.setOnAuthNotLoggedIn(null);
+    if (deps?.presencePool) {
+      const ref = deps.presencePool;
+      ref.pool = removePresence(ref.pool, controlPeerId);
+      daemon.taskManager.broadcastControl({ type: "presence_state", peers: ref.pool });
+    }
   };
   logAdapter({
     event: "control_channel_wired",
@@ -86952,6 +87672,77 @@ function handleMessageChannel(opts) {
   };
 }
 
+// src/services/collab/collab-repo-manager.ts
+var DAEMON_IDENTITY2 = { name: "shipyard-daemon", type: "service" };
+var COLLAB_VISIBLE_PREFIXES = /* @__PURE__ */ new Set(["plan", "canvas"]);
+var COLLAB_MUTABLE_PREFIXES = {
+  "collaborator-full": /* @__PURE__ */ new Set(["plan", "canvas"]),
+  "collaborator-review": /* @__PURE__ */ new Set(["plan"])
+};
+function planCollabRoomResources(taskId, roomId, epochs) {
+  return {
+    docIds: [buildPlanDocId(taskId, epochs.plan), buildCanvasDocId(taskId, epochs.canvas)],
+    personalBridgeType: `bridge-personal-${roomId}`,
+    collabBridgeType: `bridge-collab-${roomId}`
+  };
+}
+function buildCollabRepoPermissions(taskId, peerRoleRegistry) {
+  return {
+    visibility(doc3, peer) {
+      if (peer.channelKind === "storage") return true;
+      if (peer.peerType === "service") return true;
+      const parsed = parseDocumentId(doc3.id);
+      if (!parsed) return false;
+      if (parsed.key !== taskId) return false;
+      return COLLAB_VISIBLE_PREFIXES.has(parsed.prefix);
+    },
+    mutability(doc3, peer) {
+      if (peer.channelKind === "storage") return true;
+      if (peer.peerType === "service") return true;
+      const parsed = parseDocumentId(doc3.id);
+      if (!parsed) return false;
+      if (parsed.key !== taskId) return false;
+      const entry = peerRoleRegistry.getEntry(peer.peerId);
+      if (!entry) return false;
+      const allowed = COLLAB_MUTABLE_PREFIXES[entry.role];
+      return allowed ? allowed.has(parsed.prefix) : false;
+    },
+    creation(_docId, _peer) {
+      return false;
+    },
+    deletion(_doc, _peer) {
+      return false;
+    }
+  };
+}
+function createCollabRepo(personalRepo, taskId, roomId, epochs, peerRoleRegistry) {
+  const resources = planCollabRoomResources(taskId, roomId, epochs);
+  const bridge = new Bridge();
+  const personalBridgeAdapter = new BridgeAdapter({
+    adapterType: resources.personalBridgeType,
+    bridge
+  });
+  const collabBridgeAdapter = new BridgeAdapter({
+    adapterType: resources.collabBridgeType,
+    bridge
+  });
+  const collabWebrtcAdapter = new WebRtcDataChannelAdapter();
+  const collabRepo = new Repo({
+    identity: { ...DAEMON_IDENTITY2, name: `collab-room-${roomId}` },
+    adapters: [collabBridgeAdapter, collabWebrtcAdapter],
+    permissions: buildCollabRepoPermissions(taskId, peerRoleRegistry)
+  });
+  personalRepo.addAdapter(personalBridgeAdapter);
+  return {
+    repo: collabRepo,
+    webrtcAdapter: collabWebrtcAdapter,
+    async destroy() {
+      personalRepo.removeAdapter(personalBridgeAdapter.adapterId);
+      await collabRepo.shutdown();
+    }
+  };
+}
+
 // src/services/collab/collab-room-manager.ts
 function assertNever2(x2) {
   throw new Error(`Unhandled message type: ${JSON.stringify(x2)}`);
@@ -87084,6 +87875,7 @@ function createCollabRoomManager(deps) {
     for (const userId of room.knownPeers) {
       deps.peerRoleRegistry.unregisterPeer(namespacePeerId(roomId, userId));
     }
+    room.collabRepoHandle?.destroy();
     room.peerManager.destroy();
     room.connection.disconnect();
     rooms.delete(roomId);
@@ -87121,7 +87913,19 @@ function createCollabRoomManager(deps) {
         maxDelayMs: 3e4,
         backoffMultiplier: 2
       });
-      const peerManager = deps.createPeerManagerForRoom(roomId, connection, taskId);
+      const collabRepoHandle = createCollabRepo(
+        deps.personalRepo,
+        taskId,
+        roomId,
+        { plan: deps.planEpoch, canvas: deps.canvasEpoch },
+        deps.peerRoleRegistry
+      );
+      const peerManager = deps.createPeerManagerForRoom(
+        roomId,
+        connection,
+        taskId,
+        collabRepoHandle.webrtcAdapter
+      );
       const handle = {
         roomId,
         taskId,
@@ -87132,6 +87936,7 @@ function createCollabRoomManager(deps) {
       const delayMs = expiresAt - Date.now();
       if (delayMs <= 0 || !Number.isFinite(delayMs)) {
         deps.log({ event: "collab_expired", roomId, expiresAt });
+        collabRepoHandle.destroy();
         return handle;
       }
       const safeDelayMs = Math.min(delayMs, 2147483647);
@@ -87140,6 +87945,7 @@ function createCollabRoomManager(deps) {
         taskId,
         connection,
         peerManager,
+        collabRepoHandle,
         myUserId: null,
         knownPeers: /* @__PURE__ */ new Set(),
         participants: [],
@@ -87163,7 +87969,12 @@ function createCollabRoomManager(deps) {
             deps.peerRoleRegistry.unregisterPeer(namespacePeerId(roomId, userId));
           }
           room.peerManager.destroy();
-          room.peerManager = deps.createPeerManagerForRoom(roomId, connection, taskId);
+          room.peerManager = deps.createPeerManagerForRoom(
+            roomId,
+            connection,
+            taskId,
+            room.collabRepoHandle?.webrtcAdapter ?? collabRepoHandle.webrtcAdapter
+          );
           room.myUserId = null;
           room.knownPeers.clear();
         }
@@ -87204,41 +88015,20 @@ function findEntry(registry, peer) {
   }
   return void 0;
 }
-var COLLAB_VISIBLE_PREFIXES = {
-  "collaborator-full": /* @__PURE__ */ new Set(["plan", "canvas"]),
-  "collaborator-review": /* @__PURE__ */ new Set(["plan", "canvas"]),
-  viewer: /* @__PURE__ */ new Set([])
-};
-var COLLAB_MUTABLE_PREFIXES = {
-  "collaborator-full": /* @__PURE__ */ new Set(["plan", "canvas"]),
-  "collaborator-review": /* @__PURE__ */ new Set(["plan"])
-};
 function buildCollabPermissions(registry) {
+  function isAllowed(_doc, peer) {
+    if (peer.channelKind === "storage") return true;
+    if (peer.peerType === "service") return true;
+    const entry = findEntry(registry, peer);
+    if (!entry) return false;
+    return isPersonalPeer(entry);
+  }
   return {
-    visibility(doc3, peer) {
-      if (peer.channelKind === "storage") return true;
-      const entry = findEntry(registry, peer);
-      if (!entry) return false;
-      if (isPersonalPeer(entry)) return true;
-      const parsed = parseDocumentId(doc3.id);
-      if (!parsed) return false;
-      if (parsed.key !== entry.taskId) return false;
-      const allowed = COLLAB_VISIBLE_PREFIXES[entry.role];
-      return allowed ? allowed.has(parsed.prefix) : false;
-    },
-    mutability(doc3, peer) {
-      if (peer.channelKind === "storage") return true;
-      const entry = findEntry(registry, peer);
-      if (!entry) return false;
-      if (isPersonalPeer(entry)) return true;
-      const parsed = parseDocumentId(doc3.id);
-      if (!parsed) return false;
-      if (parsed.key !== entry.taskId) return false;
-      const allowed = COLLAB_MUTABLE_PREFIXES[entry.role];
-      return allowed ? allowed.has(parsed.prefix) : false;
-    },
+    visibility: isAllowed,
+    mutability: isAllowed,
     creation(_docId, peer) {
       if (peer.channelKind === "storage") return true;
+      if (peer.peerType === "service") return true;
       const entry = findEntry(registry, peer);
       if (!entry) return false;
       return isPersonalPeer(entry);
@@ -87298,8 +88088,8 @@ function createPeerRoleRegistry() {
 }
 
 // src/services/epoch-pruning.ts
-import { readdir as readdir7, rm as rm3 } from "fs/promises";
-import { join as join38 } from "path";
+import { readdir as readdir8, rm as rm3 } from "fs/promises";
+import { join as join39 } from "path";
 var LEGACY_PREFIXES = [
   "task-meta",
   "task-conv",
@@ -87316,7 +88106,7 @@ function isLegacyDocId(decoded) {
 async function pruneOldEpochData(dataDir, currentEpoch, log) {
   let entries;
   try {
-    entries = await readdir7(dataDir, { withFileTypes: true });
+    entries = await readdir8(dataDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -87334,7 +88124,7 @@ async function pruneOldEpochData(dataDir, currentEpoch, log) {
     if (!parsed) {
       if (isLegacyDocId(decoded)) {
         removals.push(
-          rm3(join38(dataDir, entry.name), { recursive: true }).then(() => {
+          rm3(join39(dataDir, entry.name), { recursive: true }).then(() => {
             pruned++;
           }).catch((err) => {
             log({
@@ -87349,7 +88139,7 @@ async function pruneOldEpochData(dataDir, currentEpoch, log) {
     }
     if (parsed.epoch >= currentEpoch) continue;
     removals.push(
-      rm3(join38(dataDir, entry.name), { recursive: true }).then(() => {
+      rm3(join39(dataDir, entry.name), { recursive: true }).then(() => {
         pruned++;
       }).catch((err) => {
         log({
@@ -87368,7 +88158,7 @@ async function pruneOldEpochData(dataDir, currentEpoch, log) {
 
 // src/services/file-io-handler.ts
 import { execFile as execFile9, spawn as spawn7 } from "child_process";
-import { readdir as readdir8, readFile as readFile25, stat as stat5, unlink as unlink6, writeFile as writeFile22 } from "fs/promises";
+import { readdir as readdir9, readFile as readFile25, stat as stat5, unlink as unlink6, writeFile as writeFile22 } from "fs/promises";
 import { normalize as normalize5, relative as relative2, resolve } from "path";
 import { promisify as promisify6 } from "util";
 function handleFileIOChannel(initialCwd, send, log, deps) {
@@ -87532,7 +88322,7 @@ function handleFileIOChannel(initialCwd, send, log, deps) {
   }
   async function handleReaddir(requestId, absPath) {
     try {
-      const entries = await readdir8(absPath, { withFileTypes: true });
+      const entries = await readdir9(absPath, { withFileTypes: true });
       const result = entries.filter((e) => !e.name.startsWith(".") && e.name !== "node_modules").map((e) => ({
         name: e.name,
         type: e.isDirectory() ? "directory" : "file"
@@ -88271,17 +89061,25 @@ function guardLoroChannelSend(dc, log) {
   const originalSend = dc.send.bind(dc);
   let dropCount = 0;
   let lastLogAt = 0;
+  const logDrop = (reason) => {
+    dropCount++;
+    const now = Date.now();
+    if (now - lastLogAt >= 1e3) {
+      log.warn({ droppedCount: dropCount, reason }, "Loro sync send dropped");
+      dropCount = 0;
+      lastLogAt = now;
+    }
+  };
   dc.send = (data) => {
+    if (dc.readyState !== void 0 && dc.readyState !== "open") return;
+    if (typeof dc.bufferedAmount === "number" && dc.bufferedAmount > LORO_BACKPRESSURE_HIGH_WATER) {
+      logDrop("backpressure");
+      return;
+    }
     try {
       originalSend(data);
     } catch {
-      dropCount++;
-      const now = Date.now();
-      if (now - lastLogAt >= 1e3) {
-        log.warn({ droppedCount: dropCount }, "Loro sync send failed (SCTP overflow)");
-        dropCount = 0;
-        lastLogAt = now;
-      }
+      logDrop("send_error");
     }
   };
 }
@@ -88526,8 +89324,8 @@ function createPeerManager(config2) {
 
 // src/services/plugins/plugin-file-watcher.ts
 import { existsSync as existsSync6, watch as watch4 } from "fs";
-import { readdir as readdir9, readFile as readFile26, stat as stat6 } from "fs/promises";
-import { join as join39 } from "path";
+import { readdir as readdir10, readFile as readFile26, stat as stat6 } from "fs/promises";
+import { join as join40 } from "path";
 import { pathToFileURL } from "url";
 var DEBOUNCE_MS2 = 500;
 var PLUGIN_ID_PATTERN2 = /^[a-z0-9][a-z0-9-]*$/;
@@ -88578,14 +89376,14 @@ var PluginFileWatcher = class {
     }
     let entries;
     try {
-      entries = await readdir9(dir);
+      entries = await readdir10(dir);
     } catch {
       this.#reconcile([]);
       return;
     }
     const loaded = [];
     for (const entry of entries) {
-      const pluginDir = join39(dir, entry);
+      const pluginDir = join40(dir, entry);
       let stats;
       try {
         stats = await stat6(pluginDir);
@@ -88600,7 +89398,7 @@ var PluginFileWatcher = class {
     this.#reconcile(loaded);
   }
   async #loadPlugin(id, pluginDir) {
-    const manifestPath = join39(pluginDir, "plugin.json");
+    const manifestPath = join40(pluginDir, "plugin.json");
     let manifestRaw;
     try {
       manifestRaw = await readFile26(manifestPath, "utf-8");
@@ -88627,7 +89425,7 @@ var PluginFileWatcher = class {
     }
     const manifest = parsed.data;
     let template = "";
-    const templatePath = join39(pluginDir, "template.html");
+    const templatePath = join40(pluginDir, "template.html");
     try {
       template = await readFile26(templatePath, "utf-8");
     } catch {
@@ -88642,7 +89440,7 @@ var PluginFileWatcher = class {
     };
   }
   async #loadAndRegisterHandler(id, pluginDir, title) {
-    const handlerPath = join39(pluginDir, "handler.mjs");
+    const handlerPath = join40(pluginDir, "handler.mjs");
     let handlerFn;
     try {
       const handlerStat = await stat6(handlerPath);
@@ -88903,28 +89701,14 @@ var HOP_BY_HOP_HEADERS2 = /* @__PURE__ */ new Set([
   "proxy-authorization",
   "proxy-connection",
   "te",
-  "host"
+  "host",
+  "accept-encoding"
 ]);
 var IFRAME_BLOCKING_HEADERS2 = /* @__PURE__ */ new Set([
   "x-frame-options",
   "content-security-policy",
   "content-security-policy-report-only"
 ]);
-function findAvailablePort2() {
-  return new Promise((resolve3, reject) => {
-    const srv = http2.createServer();
-    srv.listen(0, "127.0.0.1", () => {
-      const addr = srv.address();
-      if (typeof addr === "object" && addr) {
-        const port = addr.port;
-        srv.close(() => resolve3(port));
-      } else {
-        reject(new Error("Failed to allocate port"));
-      }
-    });
-    srv.on("error", reject);
-  });
-}
 function injectAnnotationBridge(html) {
   const headIdx = html.indexOf("<head");
   if (headIdx === -1) return ANNOTATION_BRIDGE_TAG + html;
@@ -88952,10 +89736,13 @@ function collectResponseHeaders(rawHeaders) {
   }
   return result;
 }
+var BLOCKED_PORTS = /* @__PURE__ */ new Set([22, 25, 3306, 5432, 6379, 27017]);
 function createPreviewProxy(config2) {
   const { log } = config2;
   let server = null;
   let allocatedPort = null;
+  let currentTargetPort = null;
+  let startPromise = null;
   const activeRequests = /* @__PURE__ */ new Set();
   const activeSockets = /* @__PURE__ */ new Set();
   function proxyRequest(clientReq, clientRes, targetPort) {
@@ -88963,7 +89750,7 @@ function createPreviewProxy(config2) {
     headers.host = `localhost:${targetPort}`;
     const proxyReq = http2.request(
       {
-        hostname: "127.0.0.1",
+        hostname: "localhost",
         port: targetPort,
         path: clientReq.url ?? "/",
         method: clientReq.method ?? "GET",
@@ -89041,7 +89828,7 @@ function createPreviewProxy(config2) {
     headers.connection = "Upgrade";
     headers.upgrade = clientReq.headers.upgrade ?? "websocket";
     const proxyReq = http2.request({
-      hostname: "127.0.0.1",
+      hostname: "localhost",
       port: targetPort,
       path: clientReq.url ?? "/",
       method: "GET",
@@ -89100,21 +89887,45 @@ function createPreviewProxy(config2) {
     get port() {
       return allocatedPort;
     },
+    get targetPort() {
+      return currentTargetPort;
+    },
+    retarget(port) {
+      if (port < 1 || port > 65535 || BLOCKED_PORTS.has(port)) {
+        throw new Error(`Port ${port} is not allowed for preview proxy`);
+      }
+      currentTargetPort = port;
+      log({ event: "preview_proxy_retargeted", proxyPort: allocatedPort, targetPort: port });
+    },
     async start(target) {
+      if (startPromise) await startPromise;
       if (server) {
         throw new Error("Preview proxy already started");
       }
-      allocatedPort = await findAvailablePort2();
+      if (target.port < 1 || target.port > 65535 || BLOCKED_PORTS.has(target.port)) {
+        throw new Error(`Port ${target.port} is not allowed for preview proxy`);
+      }
+      currentTargetPort = target.port;
       const srv = http2.createServer((req, res) => {
-        proxyRequest(req, res, target.port);
+        if (!currentTargetPort) {
+          res.writeHead(502, { "content-type": "text/plain" });
+          res.end("No preview target configured");
+          return;
+        }
+        proxyRequest(req, res, currentTargetPort);
       });
       server = srv;
       srv.on("upgrade", (req, socket, head) => {
-        proxyWebSocketUpgrade(req, socket, head, target.port);
+        if (!currentTargetPort) {
+          socket.destroy();
+          return;
+        }
+        proxyWebSocketUpgrade(req, socket, head, currentTargetPort);
       });
-      const listenPort = allocatedPort;
-      await new Promise((resolve3, reject) => {
-        srv.listen(listenPort, "127.0.0.1", () => {
+      startPromise = new Promise((resolve3, reject) => {
+        srv.listen(0, "localhost", () => {
+          const addr = srv.address();
+          allocatedPort = typeof addr === "object" && addr ? addr.port : null;
           log({
             event: "preview_proxy_started",
             proxyPort: allocatedPort,
@@ -89124,8 +89935,11 @@ function createPreviewProxy(config2) {
         });
         srv.on("error", reject);
       });
+      await startPromise;
+      startPromise = null;
     },
     async stop() {
+      if (startPromise) await startPromise;
       for (const req of activeRequests) {
         req.destroy();
       }
@@ -89138,6 +89952,7 @@ function createPreviewProxy(config2) {
         const srv = server;
         server = null;
         allocatedPort = null;
+        currentTargetPort = null;
         await new Promise((resolve3, reject) => {
           srv.close((err) => err ? reject(err) : resolve3());
         });
@@ -89150,7 +89965,7 @@ function createPreviewProxy(config2) {
 // src/services/storage/daemon-settings-store.ts
 import { createHash as createHash5 } from "crypto";
 import { mkdir as mkdir16, readFile as readFile27, rename as rename15, writeFile as writeFile23 } from "fs/promises";
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 var ProjectSettingsSchema = external_exports.object({
   disabledMcpServers: external_exports.array(external_exports.string()).optional()
 });
@@ -89158,9 +89973,9 @@ function hashProjectPath(projectPath) {
   return createHash5("sha256").update(projectPath).digest("hex").slice(0, 16);
 }
 function buildDaemonSettingsStore(dataDir) {
-  const settingsDir = join40(dataDir, "settings");
+  const settingsDir = join41(dataDir, "settings");
   function settingsPath(projectPath) {
-    return join40(settingsDir, `${hashProjectPath(projectPath)}.json`);
+    return join41(settingsDir, `${hashProjectPath(projectPath)}.json`);
   }
   async function ensureDir() {
     await mkdir16(settingsDir, { recursive: true });
@@ -89187,12 +90002,12 @@ function buildDaemonSettingsStore(dataDir) {
 
 // src/services/storage/plugin-config-store.ts
 import { mkdir as mkdir17, readFile as readFile28, rename as rename16, writeFile as writeFile24 } from "fs/promises";
-import { join as join41 } from "path";
+import { join as join42 } from "path";
 function buildPluginConfigStore(pluginsDir) {
   const cache2 = /* @__PURE__ */ new Map();
   const writeQueues = /* @__PURE__ */ new Map();
   function configPath(pluginId) {
-    return join41(pluginsDir, pluginId, "config.json");
+    return join42(pluginsDir, pluginId, "config.json");
   }
   async function ensureLoaded(pluginId) {
     const cached = cache2.get(pluginId);
@@ -89223,7 +90038,7 @@ function buildPluginConfigStore(pluginsDir) {
       const next = prev.then(async () => {
         const filePath = configPath(pluginId);
         const tmpPath = `${filePath}.tmp`;
-        await mkdir17(join41(pluginsDir, pluginId), { recursive: true });
+        await mkdir17(join42(pluginsDir, pluginId), { recursive: true });
         await writeFile24(tmpPath, JSON.stringify(config2, null, 2), "utf-8");
         await rename16(tmpPath, filePath);
       });
@@ -89631,7 +90446,7 @@ function resolveClaudeCodePath(log) {
   try {
     const req = createRequire4(import.meta.url);
     const sdkMain = req.resolve("@anthropic-ai/claude-agent-sdk");
-    const p2 = join42(dirname14(sdkMain), "cli.js");
+    const p2 = join43(dirname14(sdkMain), "cli.js");
     if (existsSync7(p2)) return ok("sdk_bundled", p2);
   } catch {
   }
@@ -89641,7 +90456,7 @@ function resolveClaudeCodePath(log) {
   } catch {
   }
   for (const c of [
-    join42(process.env.HOME ?? "", ".local", "bin", "claude"),
+    join43(process.env.HOME ?? "", ".local", "bin", "claude"),
     "/usr/local/bin/claude"
   ])
     if (existsSync7(c)) return ok("well_known", c);
@@ -89649,11 +90464,11 @@ function resolveClaudeCodePath(log) {
 }
 async function serve(options = {}) {
   const shipyardHome = options.shipyardHome ?? getShipyardHome();
-  const dataDir = join42(shipyardHome, options.isDev ? "data-dev" : "data");
+  const dataDir = join43(shipyardHome, options.isDev ? "data-dev" : "data");
   const log = createChildLogger({ mode: "serve" });
   const workspaceRoot = findProjectRoot(process.cwd());
   registerBuiltinPlugins();
-  const pluginConfigStore = buildPluginConfigStore(join42(dataDir, "plugins"));
+  const pluginConfigStore = buildPluginConfigStore(join43(dataDir, "plugins"));
   await mkdir18(dataDir, { recursive: true });
   log.info({ shipyardHome, dataDir, workspaceRoot }, "Starting daemon");
   function logAdapter(entry) {
@@ -89671,13 +90486,14 @@ async function serve(options = {}) {
   await lifecycle.acquirePidFile(shipyardHome);
   const pidTracker = buildPidTracker(shipyardHome);
   await pidTracker.sweepOrphans(logAdapter);
-  await pruneOldEpochData(join42(dataDir, "loro"), LEGACY_EPOCH, logAdapter);
-  const storage = new FileStorageAdapter(join42(dataDir, "loro"));
-  const webrtcAdapter = new WebRtcDataChannelAdapter();
+  await pruneOldEpochData(join43(dataDir, "loro"), LEGACY_EPOCH, logAdapter);
+  const storage = new FileStorageAdapter(join43(dataDir, "loro"));
+  const personalWebrtcAdapter = new WebRtcDataChannelAdapter();
   const peerRoleRegistry = createPeerRoleRegistry();
+  const presencePoolRef = { pool: {} };
   const repo = new Repo({
     identity: DAEMON_IDENTITY,
-    adapters: [storage, webrtcAdapter],
+    adapters: [storage, personalWebrtcAdapter],
     permissions: buildCollabPermissions(peerRoleRegistry)
   });
   const resolvedSignalingUrl = env.SHIPYARD_SIGNALING_URL ?? auth3.signalingUrl;
@@ -89726,7 +90542,7 @@ async function serve(options = {}) {
     previewProxy
   });
   daemon.healthMetrics.start();
-  const pluginsDir = join42(shipyardHome, "plugins");
+  const pluginsDir = join43(shipyardHome, "plugins");
   await mkdir18(pluginsDir, { recursive: true });
   let loadedPlugins = [];
   const pluginFileWatcher = new PluginFileWatcher({
@@ -89806,8 +90622,11 @@ async function serve(options = {}) {
   const fileIOHandlers = /* @__PURE__ */ new Set();
   const collabRoomManager = signalingHandle ? createCollabRoomManager({
     peerRoleRegistry,
-    createPeerManagerForRoom: (roomId, connection, collabTaskId) => createPeerManager({
-      webrtcAdapter,
+    personalRepo: repo,
+    planEpoch: PLAN_EPOCH,
+    canvasEpoch: CANVAS_EPOCH,
+    createPeerManagerForRoom: (roomId, connection, collabTaskId, collabWebrtcAdapter) => createPeerManager({
+      webrtcAdapter: collabWebrtcAdapter,
       log: createChildLogger({ mode: `collab-peer:${roomId}` }),
       onAnswer(namespacedId, answer) {
         const prefix = `collab:${roomId}:`;
@@ -89847,7 +90666,9 @@ async function serve(options = {}) {
           peerRoleRegistry,
           peerMachineId: machineId,
           collabTaskId,
-          configStore: pluginConfigStore
+          configStore: pluginConfigStore,
+          previewProxy,
+          presencePool: presencePoolRef
         });
         if (loadedPlugins.length > 0) {
           daemon.taskManager.broadcastControl({
@@ -90086,7 +90907,7 @@ async function serve(options = {}) {
     );
   }
   const peerManager = signalingHandle ? createPeerManager({
-    webrtcAdapter,
+    webrtcAdapter: personalWebrtcAdapter,
     onAnswer: (targetMachineId, answer) => {
       signalingHandle.connection.send({
         type: "webrtc-answer",
@@ -90114,7 +90935,10 @@ async function serve(options = {}) {
         machineId: signalingHandle.machineId,
         signalingBaseUrl: auth3.signalingUrl,
         userToken: auth3.token,
-        configStore: pluginConfigStore
+        configStore: pluginConfigStore,
+        previewProxy,
+        presencePool: presencePoolRef,
+        peerIdentity: { userId: auth3.userId, username: auth3.displayName, avatarUrl: null }
       });
       portDetector.resend();
       if (loadedPlugins.length > 0) {
@@ -90347,8 +91171,24 @@ async function serve(options = {}) {
   }
   portDetector = createPortDetector({
     workspaceRoot,
-    onPorts: (ports) => {
-      daemon.taskManager.broadcastControl({ type: "detected_ports", ports });
+    onPorts: async (ports) => {
+      const firstPort = ports[0]?.port;
+      if (firstPort && !previewProxy.port) {
+        try {
+          await previewProxy.start({ port: firstPort });
+        } catch (err) {
+          logAdapter({
+            event: "preview_proxy_auto_start_failed",
+            port: firstPort,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+      daemon.taskManager.broadcastControl({
+        type: "detected_ports",
+        ports,
+        proxyPort: previewProxy.port ?? void 0
+      });
     },
     log: logAdapter
   });
@@ -90702,4 +91542,4 @@ export {
   classifyLogLevel,
   serve
 };
-//# sourceMappingURL=serve-LL6LUMZI.js.map
+//# sourceMappingURL=serve-KBBJR56G.js.map