@schoolai/shipyard 3.13.0 → 3.14.0-rc.20260616.0

package/dist/{serve-RW42I4NC.js → serve-25I4ML7R.js}

@@ -12,7 +12,7 @@ import {
   guardedSubscribe,
   makeInitialAttemptState,
   shutdownFileWatcherGuard
-} from "./chunk-7MVFHLYV.js";
+} from "./chunk-3KE2VDKA.js";
 import {
   TRAILER_SCHEMA_VERSION,
   appendTrailerToMessage,
@@ -45,7 +45,7 @@ import {
 } from "./chunk-TFWDJCUJ.js";
 import {
   getDaemonVersion
-} from "./chunk-MR6HRO7R.js";
+} from "./chunk-WGS7ZW6N.js";
 import {
   collectPriorCrashDetail,
   getRecentWasmPanicMessages
@@ -482,7 +482,7 @@ import "./chunk-2H7UOFLK.js";
 // src/services/serve.ts
 import { mkdir as mkdir44, realpath as realpath3 } from "fs/promises";
 import { homedir as homedir15 } from "os";
-import { join as join86 } from "path";
+import { join as join87 } from "path";
 import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
 
 // ../../node_modules/.pnpm/@levischuck+tiny-cbor@0.3.2/node_modules/@levischuck/tiny-cbor/esm/cbor/cbor_internal.js
@@ -5764,7 +5764,7 @@ function nanoid(size = 21) {
 }
 
 // src/services/bootstrap/signaling.ts
-var DAEMON_NPM_VERSION = true ? "3.13.0" : "unknown";
+var DAEMON_NPM_VERSION = true ? "3.14.0" : "unknown";
 function createDaemonSignaling(config) {
   const agentId = config.agentId ?? nanoid();
   function send(msg) {
@@ -6526,6 +6526,583 @@ async function createCapabilityWatcher(deps) {
   };
 }
 
+// src/services/collab/crdt-permissions.ts
+function isPersonalPeer(entry) {
+  return entry?.source === "personal";
+}
+function findEntry(registry, peer) {
+  const direct = registry.getEntry(peer.peerId);
+  if (direct) return direct;
+  if (peer.peerType === "user") {
+    return registry.findBySource("personal");
+  }
+  return void 0;
+}
+var COLLAB_VISIBLE_PREFIXES = {
+  owner: /* @__PURE__ */ new Set(["plan", "canvas"]),
+  "collaborator-full": /* @__PURE__ */ new Set(["plan", "canvas"]),
+  "collaborator-review": /* @__PURE__ */ new Set(["plan", "canvas"]),
+  viewer: /* @__PURE__ */ new Set([])
+};
+var COLLAB_MUTABLE_PREFIXES = {
+  owner: /* @__PURE__ */ new Set(["plan", "canvas"]),
+  "collaborator-full": /* @__PURE__ */ new Set(["plan", "canvas"]),
+  "collaborator-review": /* @__PURE__ */ new Set(["plan"]),
+  viewer: /* @__PURE__ */ new Set([])
+};
+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: isAllowed,
+    mutability: isAllowed,
+    creation(docId, peer) {
+      const colonIdx = docId.indexOf(":");
+      if (colonIdx > 0 && OBSOLETE_PREFIXES.has(docId.slice(0, colonIdx))) return false;
+      if (peer.channelKind === "storage") return true;
+      if (peer.peerType === "service") return true;
+      const entry = findEntry(registry, peer);
+      if (!entry) return false;
+      return isPersonalPeer(entry);
+    },
+    deletion(_doc, _peer) {
+      return false;
+    }
+  };
+}
+function isCollabPrefixVisible(role, prefix) {
+  return COLLAB_VISIBLE_PREFIXES[role].has(prefix);
+}
+function isCollabPrefixMutable(role, prefix) {
+  return COLLAB_MUTABLE_PREFIXES[role].has(prefix);
+}
+
+// src/services/collab/collab-repo-manager.ts
+var BRIDGE_EPHEMERAL_HOPS = 1;
+var DAEMON_IDENTITY = { name: "shipyard-daemon", type: "service" };
+function restoreEphemeralHops(message) {
+  switch (message.type) {
+    case "channel/ephemeral":
+      if (message.hopsRemaining >= BRIDGE_EPHEMERAL_HOPS) return message;
+      return { ...message, hopsRemaining: BRIDGE_EPHEMERAL_HOPS };
+    case "channel/batch": {
+      let changed = false;
+      const nextMessages = message.messages.map((inner) => {
+        if (inner.type !== "channel/ephemeral") return inner;
+        if (inner.hopsRemaining >= BRIDGE_EPHEMERAL_HOPS) return inner;
+        changed = true;
+        return { ...inner, hopsRemaining: BRIDGE_EPHEMERAL_HOPS };
+      });
+      if (!changed) return message;
+      return { ...message, messages: nextMessages };
+    }
+    case "channel/establish-request":
+    case "channel/establish-response":
+    case "channel/sync-request":
+    case "channel/sync-response":
+    case "channel/update":
+    case "channel/directory-request":
+    case "channel/directory-response":
+    case "channel/new-doc":
+    case "channel/delete-request":
+    case "channel/delete-response":
+      return message;
+    default: {
+      const _exhaustive = message;
+      void _exhaustive;
+      return message;
+    }
+  }
+}
+var HopRestoringBridgeAdapter = class extends BridgeAdapter {
+  generate(context) {
+    const channel = super.generate(context);
+    const originalSend = channel.send;
+    return {
+      ...channel,
+      send: (msg) => originalSend(restoreEphemeralHops(msg))
+    };
+  }
+};
+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(doc, peer) {
+      if (peer.channelKind === "storage") return true;
+      if (peer.peerType === "service") return true;
+      const parsed = parseDocumentId(doc.id);
+      if (!parsed) return false;
+      if (parsed.key !== taskId) return false;
+      const entry = peerRoleRegistry.getEntry(peer.peerId);
+      if (!entry) return false;
+      return isCollabPrefixVisible(entry.role, parsed.prefix);
+    },
+    mutability(doc, peer) {
+      if (peer.channelKind === "storage") return true;
+      if (peer.peerType === "service") return true;
+      const parsed = parseDocumentId(doc.id);
+      if (!parsed) return false;
+      if (parsed.key !== taskId) return false;
+      const entry = peerRoleRegistry.getEntry(peer.peerId);
+      if (!entry) return false;
+      return isCollabPrefixMutable(entry.role, parsed.prefix);
+    },
+    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 HopRestoringBridgeAdapter({
+    adapterType: resources.personalBridgeType,
+    bridge
+  });
+  const collabBridgeAdapter = new HopRestoringBridgeAdapter({
+    adapterType: resources.collabBridgeType,
+    bridge
+  });
+  const collabWebrtcAdapter = new WebRtcDataChannelAdapter();
+  const collabRepo = new Repo({
+    identity: { ...DAEMON_IDENTITY, 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)}`);
+}
+function namespacePeerId(roomId, remoteUserId) {
+  return `collab:${roomId}:${remoteUserId}`;
+}
+function stripCollabRoomPrefix(roomId, namespacedId) {
+  const roomPrefix = `collab:${roomId}:`;
+  if (!namespacedId.startsWith(roomPrefix)) {
+    throw new Error(
+      `Expected collab-namespaced peer ID with prefix "${roomPrefix}", got "${namespacedId}"`
+    );
+  }
+  const browserMarker = ":browser:";
+  const browserIdx = namespacedId.lastIndexOf(browserMarker);
+  if (browserIdx === -1) {
+    throw new Error(`Expected collab peer ID to contain "${browserMarker}", got "${namespacedId}"`);
+  }
+  return namespacedId.slice(browserIdx + browserMarker.length);
+}
+function bumpAndNotify(room, deps) {
+  room.generation += 1;
+  deps.onRoomStateChanged(room.taskId);
+}
+function handleParticipantsList(room, participants, deps) {
+  if (!room.myUserId) return;
+  room.participants = participants.map((p2) => ({
+    userId: p2.userId,
+    username: p2.username,
+    avatarUrl: p2.avatarUrl,
+    role: p2.role,
+    connectionId: p2.connectionId,
+    isHub: p2.isHub
+  }));
+  room.connectionIdByUser = new Map(participants.map((p2) => [p2.userId, p2.connectionId]));
+  bumpAndNotify(room, deps);
+  for (const participant of participants) {
+    if (participant.userId === room.myUserId) continue;
+    if (room.knownPeers.has(participant.userId)) continue;
+    registerCollabParticipant(
+      room,
+      participant.userId,
+      participant.role,
+      participant.username,
+      deps
+    );
+    offerOrEnqueueParticipant(room, participant.userId, deps);
+  }
+}
+function handleParticipantJoined(room, participant, deps) {
+  if (!room.myUserId) return;
+  if (participant.userId === room.myUserId) return;
+  room.connectionIdByUser.set(participant.userId, participant.connectionId);
+  if (room.knownPeers.has(participant.userId)) return;
+  room.participants = [
+    ...room.participants,
+    {
+      userId: participant.userId,
+      username: participant.username,
+      avatarUrl: participant.avatarUrl,
+      role: participant.role,
+      connectionId: participant.connectionId,
+      isHub: participant.isHub
+    }
+  ];
+  bumpAndNotify(room, deps);
+  registerCollabParticipant(room, participant.userId, participant.role, participant.username, deps);
+  offerOrEnqueueParticipant(room, participant.userId, deps);
+}
+function handleParticipantLeft(room, msg, deps) {
+  const { userId, connectionId } = msg;
+  const tracked = room.connectionIdByUser.get(userId);
+  if (tracked !== void 0 && tracked !== connectionId) {
+    deps.log({
+      event: "participant_left_stale_dropped",
+      roomId: room.roomId,
+      userId,
+      incomingConnectionId: connectionId,
+      trackedConnectionId: tracked
+    });
+    return;
+  }
+  room.knownPeers.delete(userId);
+  room.pendingOfferUserIds.delete(userId);
+  room.participants = room.participants.filter((p2) => p2.userId !== userId);
+  room.connectionIdByUser.delete(userId);
+  bumpAndNotify(room, deps);
+  const peerId = namespacePeerId(room.roomId, userId);
+  deps.peerRoleRegistry.unregisterPeer(peerId);
+  room.peerManager.closePeer(peerId);
+  deps.log({ event: "collab_participant_left", roomId: room.roomId, userId });
+}
+function handleWebrtcSignaling(room, type, targetUserId, generationId, payload, deps) {
+  const peerId = namespacePeerId(room.roomId, targetUserId);
+  const actions = {
+    // eslint-disable-next-line no-restricted-syntax -- SDP is opaque z.unknown() from signaling
+    offer: () => room.peerManager.handleOffer(peerId, payload, generationId),
+    // eslint-disable-next-line no-restricted-syntax -- SDP is opaque z.unknown() from signaling
+    answer: () => room.peerManager.handleAnswer(peerId, payload, generationId),
+    // eslint-disable-next-line no-restricted-syntax -- ICE candidate is opaque z.unknown() from signaling
+    ice: () => room.peerManager.handleIce(peerId, payload, generationId)
+  };
+  actions[type]().catch((err3) => {
+    deps.log({
+      event: `collab_${type}_failed`,
+      roomId: room.roomId,
+      generationId,
+      error: String(err3)
+    });
+  });
+}
+function handleCollabRoomMessage(room, msg, deps) {
+  switch (msg.type) {
+    case "authenticated":
+      room.myUserId = msg.userId;
+      deps.log({ event: "collab_authenticated", roomId: room.roomId, userId: msg.userId });
+      break;
+    case "participants-list":
+      handleParticipantsList(room, msg.participants, deps);
+      break;
+    case "participant-joined":
+      handleParticipantJoined(room, msg.participant, deps);
+      break;
+    case "participant-left":
+      handleParticipantLeft(room, { userId: msg.userId, connectionId: msg.connectionId }, deps);
+      break;
+    case "webrtc-offer":
+      handleWebrtcSignaling(room, "offer", msg.targetUserId, msg.generationId, msg.offer, deps);
+      break;
+    case "webrtc-answer":
+      handleWebrtcSignaling(room, "answer", msg.targetUserId, msg.generationId, msg.answer, deps);
+      break;
+    case "webrtc-ice":
+      handleWebrtcSignaling(room, "ice", msg.targetUserId, msg.generationId, msg.candidate, deps);
+      break;
+    case "ice-servers":
+      applyIceServers(room, msg.iceServers, deps);
+      break;
+    case "error":
+      deps.log({ event: "collab_room_error", roomId: room.roomId, message: msg.message });
+      break;
+    default:
+      assertNever2(msg);
+  }
+}
+function registerCollabParticipant(room, userId, role, displayName, deps) {
+  const peerId = namespacePeerId(room.roomId, userId);
+  deps.peerRoleRegistry.registerCollabPeer(peerId, role, userId, displayName, room.taskId);
+}
+function initiateOfferToParticipant(room, remoteUserId, deps) {
+  if (!room.myUserId) return;
+  room.knownPeers.add(remoteUserId);
+  deps.log({ event: "collab_initiating_offer", roomId: room.roomId, target: remoteUserId });
+  const peerId = namespacePeerId(room.roomId, remoteUserId);
+  room.peerManager.initiateOffer(peerId).catch((err3) => {
+    deps.log({ event: "collab_offer_initiate_failed", roomId: room.roomId, error: String(err3) });
+  });
+}
+function offerOrEnqueueParticipant(room, remoteUserId, deps) {
+  if (room.iceServersReady) {
+    initiateOfferToParticipant(room, remoteUserId, deps);
+    return;
+  }
+  room.pendingOfferUserIds.add(remoteUserId);
+  deps.log({ event: "collab_offer_deferred_no_ice", roomId: room.roomId, target: remoteUserId });
+}
+function drainPendingOffers(room, deps) {
+  if (room.pendingOfferUserIds.size === 0) return;
+  const pending = [...room.pendingOfferUserIds];
+  room.pendingOfferUserIds.clear();
+  for (const userId of pending) {
+    if (userId === room.myUserId) continue;
+    if (room.knownPeers.has(userId)) continue;
+    initiateOfferToParticipant(room, userId, deps);
+  }
+}
+function applyIceServers(room, iceServers, deps) {
+  room.iceServers = iceServers;
+  room.iceServersReady = true;
+  room.peerManager.updateIceServers(iceServers);
+  deps.log({ event: "collab_ice_servers", roomId: room.roomId, count: iceServers.length });
+  drainPendingOffers(room, deps);
+}
+function resetCollabRoomForReconnect(room, deps) {
+  room.peerManager.destroy();
+  const adapter = room.collabRepoHandle?.webrtcAdapter;
+  if (adapter) {
+    room.peerManager = deps.createPeerManagerForRoom(
+      room.roomId,
+      room.connection,
+      room.taskId,
+      adapter
+    );
+    if (room.iceServers) {
+      room.peerManager.updateIceServers(room.iceServers);
+    }
+  } else {
+    deps.log({ event: "collab_reconnect_no_adapter", roomId: room.roomId });
+  }
+  room.myUserId = null;
+  room.knownPeers.clear();
+  room.pendingOfferUserIds.clear();
+  room.iceServersReady = adapter !== void 0 && room.iceServers !== null;
+}
+function shouldBroadcastRoomState(state) {
+  if (state === null) return true;
+  return state.ownerId !== "";
+}
+function createCollabRoomManager(deps) {
+  const rooms = /* @__PURE__ */ new Map();
+  async function leave(roomId, opts) {
+    const room = rooms.get(roomId);
+    if (!room) return;
+    deps.log({ event: "collab_leaving", roomId });
+    clearTimeout(room.expiryTimer);
+    room.unsubMessage();
+    room.unsubState();
+    for (const userId of room.knownPeers) {
+      deps.peerRoleRegistry.unregisterPeer(namespacePeerId(roomId, userId));
+    }
+    const destroyPromise = room.collabRepoHandle?.destroy();
+    room.peerManager.destroy();
+    room.connection.disconnect();
+    const leftTaskId = room.taskId;
+    rooms.delete(roomId);
+    if (opts?.removePersisted !== false) {
+      deps.collabHostingStore.remove(roomId).catch((err3) => {
+        deps.log({
+          event: "collab_hosting_remove_failed",
+          roomId,
+          error: err3 instanceof Error ? err3.message : String(err3)
+        });
+      });
+    }
+    deps.onRoomStateChanged(leftTaskId);
+    if (destroyPromise) {
+      await destroyPromise.catch((err3) => {
+        deps.log({
+          event: "collab_repo_destroy_failed",
+          roomId,
+          error: err3 instanceof Error ? err3.message : String(err3)
+        });
+      });
+    }
+  }
+  return {
+    joinRoom(config) {
+      const { roomId, taskId, token, expiresAt, signalingBaseUrl, userToken, machineId } = config;
+      const existing = rooms.get(roomId);
+      if (existing) {
+        const existingState = existing.connection.getState();
+        if (existing.taskId === taskId && (existingState === "connected" || existingState === "connecting")) {
+          deps.log({ event: "collab_join_dedup", roomId, state: existingState });
+          return {
+            roomId,
+            taskId,
+            async destroy() {
+              await leave(roomId);
+            }
+          };
+        }
+        deps.log({ event: "collab_replacing", roomId });
+        leave(roomId, { removePersisted: false }).catch((err3) => {
+          deps.log({
+            event: "collab_replace_leave_failed",
+            roomId,
+            error: err3 instanceof Error ? err3.message : String(err3)
+          });
+        });
+      }
+      const wsUrl = new URL(signalingBaseUrl);
+      wsUrl.pathname = ROUTES.WS_COLLAB.replace(":roomId", roomId);
+      wsUrl.searchParams.set("token", token);
+      wsUrl.searchParams.set("userToken", userToken);
+      wsUrl.searchParams.set("clientType", "agent");
+      wsUrl.searchParams.set("machineId", machineId);
+      const connection = new CollabRoomConnection({
+        url: wsUrl.toString(),
+        maxRetries: -1,
+        initialDelayMs: 1e3,
+        maxDelayMs: 3e4,
+        backoffMultiplier: 2
+      });
+      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,
+        async destroy() {
+          await leave(roomId);
+        }
+      };
+      const delayMs = expiresAt - Date.now();
+      if (delayMs <= 0 || !Number.isFinite(delayMs)) {
+        deps.log({ event: "collab_expired", roomId, expiresAt });
+        peerManager.destroy();
+        collabRepoHandle.destroy().catch((err3) => {
+          deps.log({
+            event: "collab_repo_destroy_failed",
+            roomId,
+            error: err3 instanceof Error ? err3.message : String(err3)
+          });
+        });
+        return handle;
+      }
+      const safeDelayMs = Math.min(delayMs, 2147483647);
+      const room = {
+        roomId,
+        taskId,
+        connection,
+        peerManager,
+        collabRepoHandle,
+        myUserId: null,
+        knownPeers: /* @__PURE__ */ new Set(),
+        participants: [],
+        connectionIdByUser: /* @__PURE__ */ new Map(),
+        iceServers: null,
+        iceServersReady: false,
+        pendingOfferUserIds: /* @__PURE__ */ new Set(),
+        expiresAt,
+        generation: 0,
+        expiryTimer: setTimeout(() => {
+          deps.log({ event: "collab_token_expired", roomId });
+          leave(roomId).catch((err3) => {
+            deps.log({
+              event: "collab_expiry_leave_failed",
+              roomId,
+              error: err3 instanceof Error ? err3.message : String(err3)
+            });
+          });
+        }, safeDelayMs),
+        unsubMessage: () => {
+        },
+        unsubState: () => {
+        }
+      };
+      rooms.set(roomId, room);
+      deps.collabHostingStore.persist({ roomId, taskId, token, expiresAt }).catch((err3) => {
+        deps.log({
+          event: "collab_hosting_persist_failed",
+          roomId,
+          error: err3 instanceof Error ? err3.message : String(err3)
+        });
+      });
+      room.unsubMessage = connection.onMessage((msg) => {
+        handleCollabRoomMessage(room, msg, deps);
+      });
+      room.unsubState = connection.onStateChange((state) => {
+        deps.log({ event: "collab_state_change", roomId, state });
+        if (state === "disconnected" || state === "error") {
+          resetCollabRoomForReconnect(room, deps);
+        }
+      });
+      connection.connect();
+      deps.log({ event: "collab_joining", roomId, taskId });
+      bumpAndNotify(room, deps);
+      return handle;
+    },
+    async leaveRoom(roomId) {
+      await leave(roomId);
+    },
+    getParticipantsForTask(taskId) {
+      for (const room of rooms.values()) {
+        if (room.taskId === taskId) {
+          return room.participants.filter((p2) => p2.userId !== room.myUserId).map((p2) => ({ name: p2.username, role: p2.role }));
+        }
+      }
+      return [];
+    },
+    listActiveTaskIds() {
+      const ids = [];
+      for (const room of rooms.values()) ids.push(room.taskId);
+      return ids;
+    },
+    getStateForTask(taskId) {
+      for (const room of rooms.values()) {
+        if (room.taskId !== taskId) continue;
+        const owner = room.participants.find((p2) => p2.role === "owner");
+        return {
+          roomId: room.roomId,
+          taskId: room.taskId,
+          ownerId: owner?.userId ?? "",
+          participants: room.participants,
+          expiresAt: room.expiresAt,
+          generation: room.generation
+        };
+      }
+      return null;
+    },
+    async destroy() {
+      await Promise.all(
+        [...rooms.keys()].map((roomId) => leave(roomId, { removePersisted: false }))
+      );
+    }
+  };
+}
+
 // src/services/mcp/state-snapshot.ts
 function computeTransportEnabled(server, live) {
   if (live) return live.status !== "disabled";
@@ -6855,6 +7432,7 @@ function sendInitialCollabSnapshots(handler, deps) {
   const mgr = deps.collabRoomManager;
   for (const taskId of mgr.listActiveTaskIds()) {
     const state = mgr.getStateForTask(taskId);
+    if (!shouldBroadcastRoomState(state)) continue;
     handler.sendControl({
       type: "collab_room_state",
       taskId,
@@ -12938,10 +13516,94 @@ function buildBrowserMetricsTelemetry(msg) {
     eventLoopDriftP99Ms: m2.eventLoopDriftMs?.p99 ?? null,
     longTaskTotalMs: m2.longTasks?.totalMs ?? null,
     longTaskMaxMs: m2.longTasks?.maxMs ?? null,
+    rtcSelectedCandidatePair: toTelemetryCandidatePair(m2.rtcSelectedCandidatePair ?? null),
+    networkEffectiveType: toTelemetryNetworkEffectiveType(m2.network?.effectiveType ?? null),
     controlChannelTotalBytes: m2.controlChannel?.totalBytes ?? null,
     runtimeErrorCount: m2.runtimeErrors?.errorCount ?? null
   };
 }
+function toTelemetryCandidatePair(pair) {
+  if (!pair) return null;
+  return {
+    localCandidateType: toTelemetryCandidateType(pair.localCandidateType),
+    remoteCandidateType: toTelemetryCandidateType(pair.remoteCandidateType),
+    localProtocol: toTelemetryProtocol(pair.localProtocol),
+    remoteProtocol: toTelemetryProtocol(pair.remoteProtocol),
+    protocol: formatCandidatePairProtocol(
+      toTelemetryProtocol(pair.localProtocol),
+      toTelemetryProtocol(pair.remoteProtocol)
+    ),
+    relayProtocol: toTelemetryRelayProtocol(pair.relayProtocol),
+    networkType: toTelemetryCandidateNetworkType(pair.networkType)
+  };
+}
+function formatCandidatePairProtocol(localProtocol, remoteProtocol) {
+  if (localProtocol && remoteProtocol) {
+    return localProtocol === remoteProtocol ? localProtocol : `${localProtocol}/${remoteProtocol}`;
+  }
+  return localProtocol ?? remoteProtocol;
+}
+function toTelemetryCandidateType(value) {
+  if (!value) return null;
+  switch (value) {
+    case "host":
+    case "prflx":
+    case "relay":
+    case "srflx":
+      return value;
+    default:
+      return "unknown";
+  }
+}
+function toTelemetryProtocol(value) {
+  if (!value) return null;
+  switch (value) {
+    case "tcp":
+    case "udp":
+      return value;
+    default:
+      return "unknown";
+  }
+}
+function toTelemetryRelayProtocol(value) {
+  if (!value) return null;
+  switch (value) {
+    case "tcp":
+    case "tls":
+    case "udp":
+      return value;
+    default:
+      return "unknown";
+  }
+}
+function toTelemetryNetworkEffectiveType(value) {
+  if (!value) return null;
+  switch (value) {
+    case "2g":
+    case "3g":
+    case "4g":
+    case "slow-2g":
+      return value;
+    default:
+      return "unknown";
+  }
+}
+function toTelemetryCandidateNetworkType(value) {
+  if (!value) return null;
+  switch (value) {
+    case "bluetooth":
+    case "cellular":
+    case "ethernet":
+    case "vpn":
+    case "wifi":
+    case "wimax":
+    case "wlan":
+    case "unknown":
+      return value;
+    default:
+      return "unknown";
+  }
+}
 function buildBrowserMetricsBaseLogEntry(msg, controlPeerId, daemonTs) {
   const m2 = msg.metrics;
   return {
@@ -18505,6 +19167,15 @@ function sendAttachSnapshot(handler, daemon, deps, logAdapter) {
 
 // src/shared/capabilities/anthropic-login.ts
 import { spawn as spawn7 } from "child_process";
+var VERSION_INCOMPAT_MESSAGE = "Your installed Claude CLI is too old for this sign-in method. Update it (run `claude update`, or reinstall the Claude CLI) and try again.";
+var VERSION_INCOMPAT_PATTERN = /error: unknown (option|command)/i;
+function classifyLoginExit(exitCode, output) {
+  if (exitCode === 0) return { kind: "success" };
+  if (VERSION_INCOMPAT_PATTERN.test(output)) {
+    return { kind: "version-incompatible", error: VERSION_INCOMPAT_MESSAGE };
+  }
+  return { kind: "failed", error: `Login failed (exit code ${exitCode})` };
+}
 function buildLoginArgs(method) {
   switch (method) {
     case "claude-ai":
@@ -18517,6 +19188,63 @@ function buildLoginArgs(method) {
       return ["auth", "login"];
   }
 }
+function resolveLoginBinary(log) {
+  const resolved = resolveClaudeBinaryPath(log);
+  return resolved ? { binary: resolved, usedPathFallback: false } : { binary: "claude", usedPathFallback: true };
+}
+function handleLoginSuccess(ctx) {
+  const { requestId, method, sendStatus, onAuthRefreshed, log } = ctx;
+  log({ event: "anthropic_login_completed", requestId });
+  detectAnthropicAuth(method).then((result) => {
+    if (result.kind === "preserved") {
+      log({ event: "anthropic_auth_refresh_preserved", requestId, reason: result.reason });
+      return;
+    }
+    onAuthRefreshed(result.auth);
+    log({ event: "anthropic_auth_refreshed", requestId, authStatus: result.auth });
+  }).catch((err3) => {
+    log({
+      event: "anthropic_auth_refresh_failed",
+      requestId,
+      error: err3 instanceof Error ? err3.message : String(err3)
+    });
+  }).finally(() => {
+    sendStatus({
+      type: "anthropic_login_status",
+      requestId,
+      status: "done",
+      loginUrl: null,
+      error: null
+    });
+  });
+}
+function handleLoginExit(exitCode, output, ctx) {
+  const classification = classifyLoginExit(exitCode, output);
+  switch (classification.kind) {
+    case "success":
+      handleLoginSuccess(ctx);
+      return;
+    case "version-incompatible":
+    case "failed":
+      ctx.log({
+        event: "anthropic_login_failed",
+        requestId: ctx.requestId,
+        exitCode,
+        output,
+        reason: classification.kind
+      });
+      ctx.sendStatus({
+        type: "anthropic_login_status",
+        requestId: ctx.requestId,
+        status: "error",
+        loginUrl: null,
+        error: classification.error
+      });
+      return;
+    default:
+      assertNever(classification);
+  }
+}
 function spawnAnthropicLogin(callbacks) {
   const requestId = crypto.randomUUID();
   const { sendStatus, onAuthRefreshed, log, method } = callbacks;
@@ -18529,7 +19257,9 @@ function spawnAnthropicLogin(callbacks) {
     error: null
   });
   const args = buildLoginArgs(method);
-  const child = spawn7("claude", args, {
+  const { binary, usedPathFallback } = resolveLoginBinary(log);
+  log({ event: "anthropic_login_spawn", requestId, binaryPath: binary, usedPathFallback });
+  const child = spawn7(binary, args, {
     stdio: ["ignore", "pipe", "pipe"]
   });
   let output = "";
@@ -18550,44 +19280,7 @@ function spawnAnthropicLogin(callbacks) {
   child.stdout?.on("data", handleOutput);
   child.stderr?.on("data", handleOutput);
   child.on("exit", (exitCode) => {
-    if (exitCode === 0) {
-      log({ event: "anthropic_login_completed", requestId });
-      detectAnthropicAuth(method).then((result) => {
-        if (result.kind === "preserved") {
-          log({
-            event: "anthropic_auth_refresh_preserved",
-            requestId,
-            reason: result.reason
-          });
-          return;
-        }
-        onAuthRefreshed(result.auth);
-        log({ event: "anthropic_auth_refreshed", requestId, authStatus: result.auth });
-      }).catch((err3) => {
-        log({
-          event: "anthropic_auth_refresh_failed",
-          requestId,
-          error: err3 instanceof Error ? err3.message : String(err3)
-        });
-      }).finally(() => {
-        sendStatus({
-          type: "anthropic_login_status",
-          requestId,
-          status: "done",
-          loginUrl: null,
-          error: null
-        });
-      });
-    } else {
-      log({ event: "anthropic_login_failed", requestId, exitCode, output });
-      sendStatus({
-        type: "anthropic_login_status",
-        requestId,
-        status: "error",
-        loginUrl: null,
-        error: `Login failed (exit code ${exitCode})`
-      });
-    }
+    handleLoginExit(exitCode, output, { requestId, method, sendStatus, onAuthRefreshed, log });
   });
   child.on("error", (err3) => {
     log({ event: "anthropic_login_spawn_failed", requestId, error: err3.message });
@@ -18604,7 +19297,9 @@ function spawnAnthropicLogin(callbacks) {
 function spawnAnthropicLogout(callbacks) {
   const { onComplete, log } = callbacks;
   log({ event: "anthropic_logout_requested" });
-  const child = spawn7("claude", ["auth", "logout"], {
+  const { binary, usedPathFallback } = resolveLoginBinary(log);
+  log({ event: "anthropic_logout_spawn", binaryPath: binary, usedPathFallback });
+  const child = spawn7(binary, ["auth", "logout"], {
     stdio: ["ignore", "pipe", "pipe"]
   });
   child.on("exit", (exitCode) => {
@@ -18637,7 +19332,7 @@ function spawnAnthropicLogout(callbacks) {
 }
 
 // src/shared/capabilities/codex-account-event.ts
-function assertNever2(x2) {
+function assertNever3(x2) {
   throw new Error(`Unhandled Codex AuthMode: ${JSON.stringify(x2)}`);
 }
 function decideCodexAuthFromAccountUpdated(authMode) {
@@ -18650,7 +19345,7 @@ function decideCodexAuthFromAccountUpdated(authMode) {
     case "agentIdentity":
       return { status: "authenticated", method: "chatgpt" };
     default:
-      return assertNever2(authMode);
+      return assertNever3(authMode);
   }
 }
 
@@ -28525,60 +29220,306 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
   });
 }
 
-// src/services/collab/crdt-permissions.ts
-function isPersonalPeer(entry) {
-  return entry?.source === "personal";
+// src/services/collab/collab-hosting-rehydrate.ts
+function classifyPersistedRooms(records, now) {
+  const plan = { rejoin: [], skip: [] };
+  for (const record of records) {
+    if (!record.token) {
+      plan.skip.push({ record, reason: "missing-token" });
+    } else if (record.expiresAt <= now) {
+      plan.skip.push({ record, reason: "expired" });
+    } else {
+      plan.rejoin.push(record);
+    }
+  }
+  return plan;
 }
-function findEntry(registry, peer) {
-  const direct = registry.getEntry(peer.peerId);
-  if (direct) return direct;
-  if (peer.peerType === "user") {
-    return registry.findBySource("personal");
+async function rehydrateCollabRooms(deps) {
+  const records = await deps.store.list();
+  if (records.length === 0) return;
+  const plan = classifyPersistedRooms(records, deps.now);
+  for (const { record, reason } of plan.skip) {
+    deps.log({ event: "collab_rehydrate_skip", roomId: record.roomId, reason });
+    await deps.store.remove(record.roomId).catch((err3) => {
+      deps.log({
+        event: "collab_rehydrate_sweep_failed",
+        roomId: record.roomId,
+        error: err3 instanceof Error ? err3.message : String(err3)
+      });
+    });
+  }
+  for (const record of plan.rejoin) {
+    try {
+      deps.joinRoom({
+        roomId: record.roomId,
+        taskId: record.taskId,
+        token: record.token,
+        expiresAt: record.expiresAt,
+        signalingBaseUrl: deps.signalingBaseUrl,
+        userToken: deps.userToken,
+        machineId: deps.machineId
+      });
+      deps.log({ event: "collab_rehydrate_rejoin", roomId: record.roomId, taskId: record.taskId });
+    } catch (err3) {
+      deps.log({
+        event: "collab_rehydrate_rejoin_failed",
+        roomId: record.roomId,
+        error: err3 instanceof Error ? err3.message : String(err3)
+      });
+    }
   }
-  return void 0;
 }
-var COLLAB_VISIBLE_PREFIXES = {
-  owner: /* @__PURE__ */ new Set(["plan", "canvas"]),
-  "collaborator-full": /* @__PURE__ */ new Set(["plan", "canvas"]),
-  "collaborator-review": /* @__PURE__ */ new Set(["plan", "canvas"]),
-  viewer: /* @__PURE__ */ new Set([])
-};
-var COLLAB_MUTABLE_PREFIXES = {
-  owner: /* @__PURE__ */ new Set(["plan", "canvas"]),
-  "collaborator-full": /* @__PURE__ */ new Set(["plan", "canvas"]),
-  "collaborator-review": /* @__PURE__ */ new Set(["plan"]),
-  viewer: /* @__PURE__ */ new Set([])
-};
-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);
+function startCollabRehydrate(args) {
+  const signalingBaseUrl = args.signalingBaseUrl;
+  if (!signalingBaseUrl) return;
+  void rehydrateCollabRooms({
+    store: args.store,
+    joinRoom: (config) => {
+      args.collabRoomManager.joinRoom(config);
+    },
+    signalingBaseUrl,
+    userToken: args.userToken,
+    machineId: args.machineId,
+    now: Date.now(),
+    log: args.log
+  }).catch((err3) => {
+    args.log({
+      event: "collab_rehydrate_failed",
+      error: err3 instanceof Error ? err3.message : String(err3)
+    });
+  });
+}
+
+// src/services/collab/collab-hosting-store.ts
+import { join as join34 } from "path";
+
+// src/services/storage/json-document-store.ts
+import { mkdir as mkdir14, readFile as readFile20 } from "fs/promises";
+import { dirname as dirname15 } from "path";
+var WRITE_DEBOUNCE_MS = 50;
+function applyMutations(records, mutations) {
+  for (const [id, mutation] of mutations) {
+    if (mutation.kind === "delete") {
+      delete records[id];
+    } else {
+      records[id] = mutation.data;
+    }
+  }
+}
+function resolveWaiters(waiters) {
+  for (const waiter of waiters) waiter.resolve();
+}
+function rejectWaiters(waiters, error) {
+  for (const waiter of waiters) waiter.reject(error);
+}
+function buildJsonDocumentStore(opts) {
+  const { filePath, recordSchema, currentVersion, migrate, storeName, docType } = opts;
+  let cache2 = null;
+  const listeners = /* @__PURE__ */ new Set();
+  let writeQueue = Promise.resolve();
+  const lockPath2 = `${filePath}.lock`;
+  let pendingMutations = /* @__PURE__ */ new Map();
+  let pendingFlushTimer = null;
+  let pendingFlushWaiters = [];
+  function notify(event) {
+    for (const listener of listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+  async function ensureDir() {
+    await mkdir14(dirname15(filePath), { recursive: true });
+  }
+  async function readFromDisk() {
+    try {
+      const raw = await readFile20(filePath, "utf-8");
+      return migrate(JSON.parse(raw));
+    } catch (err3) {
+      if (isEnoent(err3)) {
+        return { schemaVersion: currentVersion, records: {} };
+      }
+      if (isCorruptionError(err3)) {
+        const event = await quarantineCorruptFile({
+          path: filePath,
+          storeName,
+          docType,
+          error: err3,
+          defaultsApplied: true,
+          logger: opts.logger
+        });
+        opts.onCorrupt?.(event);
+        return { schemaVersion: currentVersion, records: {} };
+      }
+      throw err3;
+    }
+  }
+  async function readStore() {
+    if (cache2) return cache2;
+    cache2 = await readFromDisk();
+    return cache2;
+  }
+  async function flushPendingWrite() {
+    pendingFlushTimer = null;
+    const waiters = pendingFlushWaiters;
+    pendingFlushWaiters = [];
+    const mutations = pendingMutations;
+    pendingMutations = /* @__PURE__ */ new Map();
+    if (mutations.size === 0) {
+      resolveWaiters(waiters);
+      return;
+    }
+    try {
+      await commitMutations(mutations);
+      resolveWaiters(waiters);
+    } catch (err3) {
+      requeueMutations(mutations);
+      if (pendingMutations.size > 0 && pendingFlushTimer === null) {
+        pendingFlushTimer = setTimeout(() => {
+          void flushPendingWrite();
+        }, WRITE_DEBOUNCE_MS);
+      }
+      rejectWaiters(waiters, err3);
+    }
+  }
+  async function commitMutations(mutations) {
+    await withFileLock(lockPath2, async () => {
+      const disk = await readFromDisk();
+      applyMutations(disk.records, mutations);
+      await ensureDir();
+      await atomicWriteFile(filePath, JSON.stringify(disk));
+      applyMutations(disk.records, pendingMutations);
+      cache2 = disk;
+    });
+  }
+  function requeueMutations(mutations) {
+    for (const [id, mutation] of mutations) {
+      if (!pendingMutations.has(id)) pendingMutations.set(id, mutation);
+    }
+  }
+  function scheduleFlush() {
+    return new Promise((resolve12, reject) => {
+      pendingFlushWaiters.push({ resolve: resolve12, reject });
+      if (pendingFlushTimer) return;
+      pendingFlushTimer = setTimeout(() => {
+        void flushPendingWrite();
+      }, WRITE_DEBOUNCE_MS);
+    });
+  }
+  function enqueueWrite(op) {
+    let resultFlush;
+    const next = writeQueue.then(
+      async () => {
+        const out = await op();
+        resultFlush = out?.flush;
+      },
+      async () => {
+        const out = await op();
+        resultFlush = out?.flush;
+      }
+    );
+    writeQueue = next;
+    return next.then(() => resultFlush);
   }
   return {
-    visibility: isAllowed,
-    mutability: isAllowed,
-    creation(docId, peer) {
-      const colonIdx = docId.indexOf(":");
-      if (colonIdx > 0 && OBSOLETE_PREFIXES.has(docId.slice(0, colonIdx))) return false;
-      if (peer.channelKind === "storage") return true;
-      if (peer.peerType === "service") return true;
-      const entry = findEntry(registry, peer);
-      if (!entry) return false;
-      return isPersonalPeer(entry);
+    async get(id) {
+      const store = await readStore();
+      const record = store.records[id];
+      return record ?? null;
     },
-    deletion(_doc, _peer) {
-      return false;
+    async set(id, data) {
+      await enqueueWrite(async () => {
+        const store = await readStore();
+        store.records[id] = data;
+        pendingMutations.set(id, { kind: "set", data });
+        const flush = scheduleFlush();
+        notify({ kind: "set", id, data });
+        return { flush };
+      });
+    },
+    async update(id, fn) {
+      await enqueueWrite(async () => {
+        const store = await readStore();
+        const existing = store.records[id];
+        if (!existing) return void 0;
+        const parsed = recordSchema.parse(existing);
+        const updated = fn(parsed);
+        if (updated === parsed) return void 0;
+        store.records[id] = updated;
+        pendingMutations.set(id, { kind: "set", data: updated });
+        const flush = scheduleFlush();
+        notify({ kind: "set", id, data: updated });
+        return { flush };
+      });
+    },
+    async delete(id) {
+      await enqueueWrite(async () => {
+        const store = await readStore();
+        if (!(id in store.records)) return void 0;
+        delete store.records[id];
+        pendingMutations.set(id, { kind: "delete" });
+        const flush = scheduleFlush();
+        notify({ kind: "delete", id });
+        return { flush };
+      });
+    },
+    async list() {
+      const store = await readStore();
+      return { ...store.records };
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
     }
   };
 }
-function isCollabPrefixVisible(role, prefix) {
-  return COLLAB_VISIBLE_PREFIXES[role].has(prefix);
+
+// src/services/collab/collab-hosting-store.ts
+var CollabHostingRecordSchema = external_exports.object({
+  roomId: external_exports.string().min(1),
+  taskId: external_exports.string().min(1),
+  token: external_exports.string().min(1),
+  expiresAt: external_exports.number()
+});
+var COLLAB_HOSTING_STORE_VERSION = 1;
+var StoreEnvelopeSchema = external_exports.object({
+  records: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
+});
+function migrateCollabHostingStore(raw) {
+  const records = {};
+  const envelope = StoreEnvelopeSchema.safeParse(raw);
+  if (!envelope.success || !envelope.data.records) {
+    return { schemaVersion: COLLAB_HOSTING_STORE_VERSION, records };
+  }
+  for (const [id, value] of Object.entries(envelope.data.records)) {
+    const parsed = CollabHostingRecordSchema.safeParse(value);
+    if (parsed.success) records[id] = parsed.data;
+  }
+  return { schemaVersion: COLLAB_HOSTING_STORE_VERSION, records };
 }
-function isCollabPrefixMutable(role, prefix) {
-  return COLLAB_MUTABLE_PREFIXES[role].has(prefix);
+function buildCollabHostingStore(dataDir) {
+  const store = buildJsonDocumentStore({
+    storeName: "collab-hosting",
+    docType: "generic",
+    filePath: join34(dataDir, "collab-rooms.json"),
+    recordSchema: CollabHostingRecordSchema,
+    currentVersion: COLLAB_HOSTING_STORE_VERSION,
+    migrate: migrateCollabHostingStore
+  });
+  return {
+    async persist(record) {
+      await store.set(record.roomId, record);
+    },
+    async remove(roomId) {
+      await store.delete(roomId);
+    },
+    async list() {
+      return Object.values(await store.list());
+    }
+  };
 }
 
 // src/services/collab/peer-role-registry.ts
@@ -28651,7 +29592,7 @@ function createPeerRoleRegistry() {
 
 // src/services/epoch-pruning.ts
 import { readdir as readdir13, rm as rm7 } from "fs/promises";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 var LEGACY_PREFIXES = [
   "task-meta",
   "task-conv",
@@ -28691,7 +29632,7 @@ async function pruneOldEpochData(dataDir, log) {
     }
     if (!shouldPrune(decoded)) continue;
     removals.push(
-      rm7(join34(dataDir, entry.name), { recursive: true }).then(() => {
+      rm7(join35(dataDir, entry.name), { recursive: true }).then(() => {
         pruned++;
       }).catch((err3) => {
         log({
@@ -28710,7 +29651,7 @@ async function pruneOldEpochData(dataDir, log) {
 
 // src/services/file-watcher.ts
 import { existsSync as existsSync4 } from "fs";
-import { dirname as dirname15, relative as relative6 } from "path";
+import { dirname as dirname16, relative as relative6 } from "path";
 var IGNORE_GLOBS = [
   ".git",
   "node_modules",
@@ -28844,7 +29785,7 @@ async function startWatcher(cwd, entry, log) {
       event: "file_watcher_pool_create_failed",
       cwd,
       cwdExists: pathExistsForLog(cwd),
-      parentExists: pathExistsForLog(dirname15(cwd)),
+      parentExists: pathExistsForLog(dirname16(cwd)),
       error: err3 instanceof Error ? err3.message : String(err3)
     });
   }
@@ -29310,7 +30251,7 @@ function routeDataChannel(label) {
   }
   return { kind: "unknown", label };
 }
-function assertNever3(x2) {
+function assertNever4(x2) {
   throw new Error(`Unhandled channel route: ${JSON.stringify(x2)}`);
 }
 function machineIdToPeerId(machineId) {
@@ -29463,7 +30404,14 @@ function installControlGuard(dc, label, machineId, log, logAdapter, dcBufferedSa
 var HANDSHAKE_TIMEOUT_MS = 3e4;
 function noopLogAdapter(_entry) {
 }
+function decideStaleSignal(entry, incoming) {
+  if (!entry) return { action: "drop" };
+  if (entry.generationId === incoming.generationId) return { action: "apply" };
+  if (entry.lastState === "new") return { action: "reoffer", generationId: entry.generationId };
+  return { action: "drop" };
+}
 var DISCONNECT_WATCHDOG_MS = 5e3;
+var REOFFER_THROTTLE_MS = 1e3;
 function createPeerManager(config) {
   const peers = /* @__PURE__ */ new Map();
   const pendingCreates = /* @__PURE__ */ new Map();
@@ -29594,6 +30542,46 @@ function createPeerManager(config) {
       }
     };
   }
+  function logStaleAnswer(fromMachineId, currentGenerationId, staleGenerationId) {
+    config.logAdapter?.({
+      event: "webrtc_answer_stale",
+      fromMachineId,
+      currentGenerationId,
+      staleGenerationId
+    });
+    config.log.debug(
+      { fromMachineId, currentGenerationId, staleGenerationId },
+      "Dropping stale WebRTC answer"
+    );
+  }
+  function logStaleIce(fromMachineId, currentGenerationId, staleGenerationId) {
+    config.logAdapter?.({
+      event: "webrtc_ice_candidate_stale",
+      fromMachineId,
+      currentGenerationId,
+      staleGenerationId
+    });
+    config.log.debug(
+      { fromMachineId, currentGenerationId, staleGenerationId },
+      "Dropping stale ICE candidate"
+    );
+  }
+  function reemitOfferForDesync(machineId, entry, trigger) {
+    if (!entry.offerSdp || !config.onOffer) return false;
+    const now = Date.now();
+    if (entry.lastReofferAt !== void 0 && now - entry.lastReofferAt < REOFFER_THROTTLE_MS) {
+      return true;
+    }
+    entry.lastReofferAt = now;
+    config.onOffer(machineId, { type: "offer", sdp: entry.offerSdp }, entry.generationId);
+    config.logAdapter?.({
+      event: "webrtc_reoffer_sent",
+      machineId,
+      generationId: entry.generationId,
+      trigger
+    });
+    return true;
+  }
   function tearDownPeer(machineId, reason) {
     const peerId = machineIdToPeerId(machineId);
     disposeLoroGuard(peerId);
@@ -29770,7 +30758,7 @@ function createPeerManager(config) {
           return;
         }
         default:
-          assertNever3(route);
+          assertNever4(route);
       }
     } catch (err3) {
       config.log.warn(
@@ -29960,7 +30948,8 @@ function createPeerManager(config) {
             generationId,
             createdAt: now,
             lastState: "new",
-            lastStateAt: now
+            lastStateAt: now,
+            offerSdp: offer.sdp
           };
           if (pendingCreates.get(targetMachineId) !== promise) {
             disposeLoroGuard(machineIdToPeerId(targetMachineId));
@@ -30007,44 +30996,44 @@ function createPeerManager(config) {
     async handleAnswer(fromMachineId, answer, generationId) {
       const entry = await resolveLiveEntry(fromMachineId, "answer", generationId);
       if (!entry) return;
-      if (entry.generationId !== generationId) {
-        config.logAdapter?.({
-          event: "webrtc_answer_stale",
-          fromMachineId,
-          currentGenerationId: entry.generationId,
-          staleGenerationId: generationId
-        });
-        config.log.debug(
-          {
-            fromMachineId,
-            currentGenerationId: entry.generationId,
-            staleGenerationId: generationId
-          },
-          "Dropping stale WebRTC answer"
-        );
-        return;
+      const decision = decideStaleSignal(
+        { generationId: entry.generationId, lastState: entry.lastState },
+        { kind: "answer", generationId }
+      );
+      switch (decision.action) {
+        case "apply":
+          break;
+        case "reoffer":
+          if (reemitOfferForDesync(fromMachineId, entry, "answer")) return;
+          logStaleAnswer(fromMachineId, entry.generationId, generationId);
+          return;
+        case "drop":
+          logStaleAnswer(fromMachineId, entry.generationId, generationId);
+          return;
+        default:
+          return assertNever4(decision);
       }
       await entry.pc.setRemoteDescription(answer);
     },
     async handleIce(fromMachineId, candidate, generationId) {
       const entry = await resolveLiveEntry(fromMachineId, "ice", generationId);
       if (!entry) return;
-      if (entry.generationId !== generationId) {
-        config.logAdapter?.({
-          event: "webrtc_ice_candidate_stale",
-          fromMachineId,
-          currentGenerationId: entry.generationId,
-          staleGenerationId: generationId
-        });
-        config.log.debug(
-          {
-            fromMachineId,
-            currentGenerationId: entry.generationId,
-            staleGenerationId: generationId
-          },
-          "Dropping stale ICE candidate"
-        );
-        return;
+      const decision = decideStaleSignal(
+        { generationId: entry.generationId, lastState: entry.lastState },
+        { kind: "ice", generationId }
+      );
+      switch (decision.action) {
+        case "apply":
+          break;
+        case "reoffer":
+          if (reemitOfferForDesync(fromMachineId, entry, "ice")) return;
+          logStaleIce(fromMachineId, entry.generationId, generationId);
+          return;
+        case "drop":
+          logStaleIce(fromMachineId, entry.generationId, generationId);
+          return;
+        default:
+          return assertNever4(decision);
       }
       try {
         await entry.pc.addIceCandidate(candidate);
@@ -30428,7 +31417,7 @@ function createLocalDirectPeer(config) {
         return;
       }
       default:
-        assertNever4(route);
+        assertNever5(route);
     }
   }
   function handleOpen(label) {
@@ -30534,7 +31523,7 @@ function createLocalDirectPeer(config) {
           );
           return;
         default:
-          return assertNever4(frame);
+          return assertNever5(frame);
       }
     },
     dispose(reason) {
@@ -30555,7 +31544,7 @@ function createLocalDirectPeer(config) {
     }
   };
 }
-function assertNever4(x2) {
+function assertNever5(x2) {
   throw new Error(`Unhandled local-direct route: ${JSON.stringify(x2)}`);
 }
 
@@ -30932,8 +31921,8 @@ function onConnection(ws, deps, peers) {
 }
 
 // src/services/local-direct/local-direct-token.ts
-import { chmod as chmod2, mkdir as mkdir14, rename as rename12, rm as rm8, writeFile as writeFile14 } from "fs/promises";
-import { dirname as dirname16, join as join35 } from "path";
+import { chmod as chmod2, mkdir as mkdir15, rename as rename12, rm as rm8, writeFile as writeFile14 } from "fs/promises";
+import { dirname as dirname17, join as join36 } from "path";
 var ADVERTISEMENT_FILE = "local-direct.json";
 var ADVERTISEMENT_MODE = 384;
 var ADVERTISEMENT_DIR_MODE = 448;
@@ -30942,12 +31931,12 @@ function generateLocalDirectToken() {
   return nanoid(TOKEN_LENGTH);
 }
 function advertisementPath(shipyardHome) {
-  return join35(shipyardHome, "data", ADVERTISEMENT_FILE);
+  return join36(shipyardHome, "data", ADVERTISEMENT_FILE);
 }
 async function writeAdvertisement(shipyardHome, ad) {
   const target = advertisementPath(shipyardHome);
-  const dir = dirname16(target);
-  await mkdir14(dir, { recursive: true, mode: ADVERTISEMENT_DIR_MODE });
+  const dir = dirname17(target);
+  await mkdir15(dir, { recursive: true, mode: ADVERTISEMENT_DIR_MODE });
   try {
     await chmod2(dir, ADVERTISEMENT_DIR_MODE);
   } catch {
@@ -31208,8 +32197,8 @@ async function setupPluginEventWiring(deps) {
 // src/services/plugins/plugin-file-watcher.ts
 import { exec as execCb2 } from "child_process";
 import { existsSync as existsSync5 } from "fs";
-import { readdir as readdir14, readFile as readFile20, stat as stat11 } from "fs/promises";
-import { basename as basename7, dirname as dirname17, join as join36 } from "path";
+import { readdir as readdir14, readFile as readFile21, stat as stat11 } from "fs/promises";
+import { basename as basename7, dirname as dirname18, join as join37 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { promisify as promisify7 } from "util";
 
@@ -31344,7 +32333,7 @@ var PluginFileWatcher = class {
     }
     const loaded = [];
     for (const entry of entries) {
-      const pluginDir = join36(dir, entry);
+      const pluginDir = join37(dir, entry);
       let stats;
       try {
         stats = await stat11(pluginDir);
@@ -31359,10 +32348,10 @@ var PluginFileWatcher = class {
     this.#reconcile(loaded);
   }
   async #loadPlugin(id, pluginDir) {
-    const manifestPath = join36(pluginDir, "plugin.json");
+    const manifestPath = join37(pluginDir, "plugin.json");
     let manifestRaw;
     try {
-      manifestRaw = await readFile20(manifestPath, "utf-8");
+      manifestRaw = await readFile21(manifestPath, "utf-8");
     } catch {
       this.#config.log({ event: "plugin_manifest_missing", pluginId: id, pluginDir });
       return null;
@@ -31396,9 +32385,9 @@ var PluginFileWatcher = class {
       return null;
     }
     let template = "";
-    const templatePath = join36(pluginDir, "template.html");
+    const templatePath = join37(pluginDir, "template.html");
     try {
-      template = await readFile20(templatePath, "utf-8");
+      template = await readFile21(templatePath, "utf-8");
     } catch {
     }
     await this.#loadAndRegisterHandler(id, pluginDir, manifest.title, manifest);
@@ -31411,7 +32400,7 @@ var PluginFileWatcher = class {
     };
   }
   async #loadAndRegisterHandler(id, pluginDir, title, manifest) {
-    const handlerPath = join36(pluginDir, "handler.mjs");
+    const handlerPath = join37(pluginDir, "handler.mjs");
     const loaded = await this.#resolveHandler(id, handlerPath);
     const { handlerFn, provideResourcesFn } = loaded;
     if (manifest.provideResources && provideResourcesFn && this.#config.resourceResolver) {
@@ -31575,7 +32564,7 @@ async function findNativeDependencyMarker(pluginDir) {
 }
 async function scanNativeDependencyDir(dir, stack) {
   for (const entry of await readNativeScanEntries(dir)) {
-    const fullPath = join36(dir, entry.name);
+    const fullPath = join37(dir, entry.name);
     if (isNativeDependencyMarker(entry, dir)) return fullPath;
     if (shouldDescendForNativeScan(entry)) stack.push(fullPath);
   }
@@ -31595,12 +32584,12 @@ function shouldDescendForNativeScan(entry) {
   return entry.isDirectory() && entry.name !== ".git" && entry.name !== NATIVE_DEP_MARKER_DIR;
 }
 function isNodeBuildReleaseDir(dir) {
-  return basename7(dir) === "Release" && basename7(dirname17(dir)) === "build";
+  return basename7(dir) === "Release" && basename7(dirname18(dir)) === "build";
 }
 
 // src/services/port-detection.ts
 import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname18, join as join37 } from "path";
+import { dirname as dirname19, join as join38 } from "path";
 var LSOF_TIMEOUT_MS = 8e3;
 var LSOF_TTL_MS = 5e3;
 var DEFAULT_POLL_INTERVAL_MS = 5e3;
@@ -31783,7 +32772,7 @@ function hasStringName(val) {
 function resolveProjectRoot(cwd) {
   let dir = cwd;
   while (true) {
-    const candidate = join37(dir, "package.json");
+    const candidate = join38(dir, "package.json");
     if (existsSync6(candidate)) {
       let packageName;
       try {
@@ -31796,7 +32785,7 @@ function resolveProjectRoot(cwd) {
       }
       return { projectRoot: dir, packageName };
     }
-    const parent = dirname18(dir);
+    const parent = dirname19(dir);
     if (parent === dir) {
       return {};
     }
@@ -31907,7 +32896,7 @@ import {
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync2
 } from "fs";
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 function isEnoent6(err3) {
   return err3 instanceof Error && Reflect.get(err3, "code") === "ENOENT";
 }
@@ -31917,7 +32906,7 @@ function atomicWriteSync(filePath, content) {
   renameSync(tmpPath, filePath);
 }
 function recordFilePath2(rootDir, taskId, elementId) {
-  return join38(rootDir, taskId, `${elementId}.json`);
+  return join39(rootDir, taskId, `${elementId}.json`);
 }
 function parseRecord2(filePath, logger2) {
   let raw;
@@ -31957,7 +32946,7 @@ function createPreviewStateStore(opts) {
     return taskMap;
   }
   function scanTaskDir(taskId) {
-    const taskPath = join38(rootDir, taskId);
+    const taskPath = join39(rootDir, taskId);
     let files;
     try {
       files = readdirSync4(taskPath);
@@ -31966,7 +32955,7 @@ function createPreviewStateStore(opts) {
     }
     for (const file of files) {
       if (!file.endsWith(".json")) continue;
-      const record = parseRecord2(join38(taskPath, file), logger2);
+      const record = parseRecord2(join39(taskPath, file), logger2);
       if (record) getTaskMap(taskId).set(record.elementId, record);
     }
   }
@@ -31992,7 +32981,7 @@ function createPreviewStateStore(opts) {
   function writeToDisk(taskId, state) {
     const filePath = recordFilePath2(rootDir, taskId, state.elementId);
     try {
-      mkdirSync3(join38(rootDir, taskId), { recursive: true });
+      mkdirSync3(join39(rootDir, taskId), { recursive: true });
       atomicWriteSync(filePath, JSON.stringify(state));
     } catch (err3) {
       logger2.warn(
@@ -33362,633 +34351,172 @@ function handleAssetChannel(dc, assetStore, deliverableStore, allowedTaskId, log
     }).catch((err3) => {
       log({
         event: "asset_upload_failed",
-        requestId,
-        error: err3 instanceof Error ? err3.message : String(err3)
-      });
-      rawSend(
-        JSON.stringify({
-          type: "upload-error",
-          requestId,
-          error: err3 instanceof Error ? err3.message : "Upload failed"
-        })
-      );
-    });
-  }
-  async function handleDownloadRequest(requestId, assetId) {
-    try {
-      const { data, meta } = await assetStore.read(assetId);
-      rawSend(
-        JSON.stringify({
-          type: "download-head",
-          requestId,
-          mimeType: meta.mimeType,
-          totalBytes: data.byteLength
-        })
-      );
-      const shell = createDownloadShell(requestId);
-      downloadShells.set(requestId, shell);
-      await shell.initialize();
-      await shell.setConnected(true);
-      const bytes = new Uint8Array(data);
-      let chunkIndex = 0;
-      let yieldCounter = 0;
-      for (let offset = 0; offset < bytes.byteLength; offset += ASSET_CHUNK_SIZE) {
-        const end = Math.min(offset + ASSET_CHUNK_SIZE, bytes.byteLength);
-        const chunk = bytes.subarray(offset, end);
-        await shell.send({
-          kind: "download-chunk",
-          requestId,
-          chunkIndex,
-          data: encodeChunk(chunk)
-        });
-        chunkIndex++;
-        yieldCounter++;
-        if (yieldCounter % YIELD_EVERY_CHUNKS === 0) {
-          await new Promise((r) => setTimeout(r, 0));
-        }
-      }
-      rawSend(JSON.stringify({ type: "download-done", requestId }));
-      log({ event: "asset_download_complete", requestId, assetId, size: data.byteLength });
-      setTimeout(() => downloadShells.delete(requestId), UPLOAD_TIMEOUT_MS);
-    } catch (err3) {
-      downloadShells.delete(requestId);
-      const { event, reason } = classifyDownloadError(assetId, err3);
-      log({ event, requestId, assetId, error: reason });
-      rawSend(
-        JSON.stringify({
-          type: "download-error",
-          requestId,
-          error: err3 instanceof Error ? err3.message : "Download failed"
-        })
-      );
-    }
-  }
-  async function handleDeliverableFileRequest(requestId, taskId, deliverableId) {
-    const resolved = await resolveDeliverableFile(deliverableStore, taskId, deliverableId);
-    if (resolved.kind === "error") {
-      log({
-        event: resolved.event,
-        requestId,
-        taskId,
-        deliverableId,
-        ...resolved.logExtras
-      });
-      rawSend(JSON.stringify({ type: "download-error", requestId, error: "" }));
-      return;
-    }
-    if (allowedTaskId !== null && resolved.recordTaskId !== allowedTaskId) {
-      log({
-        event: "deliverable_file_task_scope_mismatch",
-        level: "warn",
-        requestId,
-        allowedTaskId,
-        requestedTaskId: taskId
-      });
-      rawSend(JSON.stringify({ type: "download-error", requestId, error: "" }));
-      return;
-    }
-    const { filePath, mimeType } = resolved;
-    try {
-      const data = await fsReadFile(filePath);
-      rawSend(
-        JSON.stringify({
-          type: "download-head",
-          requestId,
-          mimeType,
-          totalBytes: data.byteLength
-        })
-      );
-      const shell = createDownloadShell(requestId);
-      downloadShells.set(requestId, shell);
-      await shell.initialize();
-      await shell.setConnected(true);
-      const bytes = new Uint8Array(data);
-      let chunkIndex = 0;
-      let yieldCounter = 0;
-      for (let offset = 0; offset < bytes.byteLength; offset += ASSET_CHUNK_SIZE) {
-        const end = Math.min(offset + ASSET_CHUNK_SIZE, bytes.byteLength);
-        const chunk = bytes.subarray(offset, end);
-        await shell.send({
-          kind: "download-chunk",
-          requestId,
-          chunkIndex,
-          data: encodeChunk(chunk)
-        });
-        chunkIndex++;
-        yieldCounter++;
-        if (yieldCounter % YIELD_EVERY_CHUNKS === 0) {
-          await new Promise((r) => setTimeout(r, 0));
-        }
-      }
-      rawSend(JSON.stringify({ type: "download-done", requestId }));
-      log({
-        event: "deliverable_file_download_complete",
-        requestId,
-        deliverableId,
-        size: data.byteLength
-      });
-      setTimeout(() => downloadShells.delete(requestId), UPLOAD_TIMEOUT_MS);
-    } catch (err3) {
-      downloadShells.delete(requestId);
-      const reason = err3 instanceof Error ? err3.message : String(err3);
-      log({
-        event: "deliverable_file_download_failed",
-        level: "warn",
-        requestId,
-        deliverableId,
-        error: reason
-      });
-      rawSend(JSON.stringify({ type: "download-error", requestId, error: "" }));
-    }
-  }
-  dc.onmessage = (event) => {
-    if (typeof event.data === "string") {
-      const data = event.data;
-      receiveQueue = receiveQueue.then(() => handleTextMessage(data)).catch((err3) => {
-        log({
-          event: "asset_channel_handler_error",
-          error: err3 instanceof Error ? err3.message : String(err3)
-        });
-      });
-    }
-  };
-  dc.onclose = () => {
-    for (const upload of pendingUploads.values()) clearTimeout(upload.timer);
-    pendingUploads.clear();
-    downloadShells.clear();
-    guardedText.dispose();
-    receiveQueue = Promise.resolve();
-  };
-  return {
-    dispose() {
-      dc.onmessage = null;
-      dc.onclose = null;
-      for (const upload of pendingUploads.values()) clearTimeout(upload.timer);
-      pendingUploads.clear();
-      downloadShells.clear();
-      guardedText.dispose();
-      receiveQueue = Promise.resolve();
-    }
-  };
-}
-
-// src/services/collab/collab-repo-manager.ts
-var BRIDGE_EPHEMERAL_HOPS = 1;
-var DAEMON_IDENTITY = { name: "shipyard-daemon", type: "service" };
-function restoreEphemeralHops(message) {
-  switch (message.type) {
-    case "channel/ephemeral":
-      if (message.hopsRemaining >= BRIDGE_EPHEMERAL_HOPS) return message;
-      return { ...message, hopsRemaining: BRIDGE_EPHEMERAL_HOPS };
-    case "channel/batch": {
-      let changed = false;
-      const nextMessages = message.messages.map((inner) => {
-        if (inner.type !== "channel/ephemeral") return inner;
-        if (inner.hopsRemaining >= BRIDGE_EPHEMERAL_HOPS) return inner;
-        changed = true;
-        return { ...inner, hopsRemaining: BRIDGE_EPHEMERAL_HOPS };
-      });
-      if (!changed) return message;
-      return { ...message, messages: nextMessages };
-    }
-    case "channel/establish-request":
-    case "channel/establish-response":
-    case "channel/sync-request":
-    case "channel/sync-response":
-    case "channel/update":
-    case "channel/directory-request":
-    case "channel/directory-response":
-    case "channel/new-doc":
-    case "channel/delete-request":
-    case "channel/delete-response":
-      return message;
-    default: {
-      const _exhaustive = message;
-      void _exhaustive;
-      return message;
-    }
-  }
-}
-var HopRestoringBridgeAdapter = class extends BridgeAdapter {
-  generate(context) {
-    const channel = super.generate(context);
-    const originalSend = channel.send;
-    return {
-      ...channel,
-      send: (msg) => originalSend(restoreEphemeralHops(msg))
-    };
-  }
-};
-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(doc, peer) {
-      if (peer.channelKind === "storage") return true;
-      if (peer.peerType === "service") return true;
-      const parsed = parseDocumentId(doc.id);
-      if (!parsed) return false;
-      if (parsed.key !== taskId) return false;
-      const entry = peerRoleRegistry.getEntry(peer.peerId);
-      if (!entry) return false;
-      return isCollabPrefixVisible(entry.role, parsed.prefix);
-    },
-    mutability(doc, peer) {
-      if (peer.channelKind === "storage") return true;
-      if (peer.peerType === "service") return true;
-      const parsed = parseDocumentId(doc.id);
-      if (!parsed) return false;
-      if (parsed.key !== taskId) return false;
-      const entry = peerRoleRegistry.getEntry(peer.peerId);
-      if (!entry) return false;
-      return isCollabPrefixMutable(entry.role, parsed.prefix);
-    },
-    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 HopRestoringBridgeAdapter({
-    adapterType: resources.personalBridgeType,
-    bridge
-  });
-  const collabBridgeAdapter = new HopRestoringBridgeAdapter({
-    adapterType: resources.collabBridgeType,
-    bridge
-  });
-  const collabWebrtcAdapter = new WebRtcDataChannelAdapter();
-  const collabRepo = new Repo({
-    identity: { ...DAEMON_IDENTITY, 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 assertNever5(x2) {
-  throw new Error(`Unhandled message type: ${JSON.stringify(x2)}`);
-}
-function namespacePeerId(roomId, remoteUserId) {
-  return `collab:${roomId}:${remoteUserId}`;
-}
-function stripCollabRoomPrefix(roomId, namespacedId) {
-  const roomPrefix = `collab:${roomId}:`;
-  if (!namespacedId.startsWith(roomPrefix)) {
-    throw new Error(
-      `Expected collab-namespaced peer ID with prefix "${roomPrefix}", got "${namespacedId}"`
-    );
-  }
-  const browserMarker = ":browser:";
-  const browserIdx = namespacedId.lastIndexOf(browserMarker);
-  if (browserIdx === -1) {
-    throw new Error(`Expected collab peer ID to contain "${browserMarker}", got "${namespacedId}"`);
-  }
-  return namespacedId.slice(browserIdx + browserMarker.length);
-}
-function bumpAndNotify(room, deps) {
-  room.generation += 1;
-  deps.onRoomStateChanged?.(room.taskId);
-}
-function handleParticipantsList(room, participants, deps) {
-  if (!room.myUserId) return;
-  room.participants = participants.map((p2) => ({
-    userId: p2.userId,
-    username: p2.username,
-    avatarUrl: p2.avatarUrl,
-    role: p2.role,
-    connectionId: p2.connectionId,
-    isHub: p2.isHub
-  }));
-  for (const p2 of participants) {
-    room.connectionIdByUser.set(p2.userId, p2.connectionId);
-  }
-  bumpAndNotify(room, deps);
-  for (const participant of participants) {
-    if (participant.userId === room.myUserId) continue;
-    if (room.knownPeers.has(participant.userId)) continue;
-    registerCollabParticipant(
-      room,
-      participant.userId,
-      participant.role,
-      participant.username,
-      deps
-    );
-    initiateOfferToParticipant(room, participant.userId, deps);
-  }
-}
-function handleParticipantJoined(room, participant, deps) {
-  if (!room.myUserId) return;
-  if (participant.userId === room.myUserId) return;
-  room.connectionIdByUser.set(participant.userId, participant.connectionId);
-  if (room.knownPeers.has(participant.userId)) return;
-  room.participants = [
-    ...room.participants,
-    {
-      userId: participant.userId,
-      username: participant.username,
-      avatarUrl: participant.avatarUrl,
-      role: participant.role,
-      connectionId: participant.connectionId,
-      isHub: participant.isHub
-    }
-  ];
-  bumpAndNotify(room, deps);
-  registerCollabParticipant(room, participant.userId, participant.role, participant.username, deps);
-  initiateOfferToParticipant(room, participant.userId, deps);
-}
-function handleParticipantLeft(room, msg, deps) {
-  const { userId, connectionId } = msg;
-  const tracked = room.connectionIdByUser.get(userId);
-  if (tracked !== void 0 && tracked !== connectionId) {
-    deps.log({
-      event: "participant_left_stale_dropped",
-      roomId: room.roomId,
-      userId,
-      incomingConnectionId: connectionId,
-      trackedConnectionId: tracked
-    });
-    return;
-  }
-  room.knownPeers.delete(userId);
-  room.participants = room.participants.filter((p2) => p2.userId !== userId);
-  room.connectionIdByUser.delete(userId);
-  bumpAndNotify(room, deps);
-  const peerId = namespacePeerId(room.roomId, userId);
-  deps.peerRoleRegistry.unregisterPeer(peerId);
-  room.peerManager.closePeer(peerId);
-  deps.log({ event: "collab_participant_left", roomId: room.roomId, userId });
-}
-function handleWebrtcSignaling(room, type, targetUserId, generationId, payload, deps) {
-  const peerId = namespacePeerId(room.roomId, targetUserId);
-  const actions = {
-    // eslint-disable-next-line no-restricted-syntax -- SDP is opaque z.unknown() from signaling
-    offer: () => room.peerManager.handleOffer(peerId, payload, generationId),
-    // eslint-disable-next-line no-restricted-syntax -- SDP is opaque z.unknown() from signaling
-    answer: () => room.peerManager.handleAnswer(peerId, payload, generationId),
-    // eslint-disable-next-line no-restricted-syntax -- ICE candidate is opaque z.unknown() from signaling
-    ice: () => room.peerManager.handleIce(peerId, payload, generationId)
-  };
-  actions[type]().catch((err3) => {
-    deps.log({
-      event: `collab_${type}_failed`,
-      roomId: room.roomId,
-      generationId,
-      error: String(err3)
-    });
-  });
-}
-function handleCollabRoomMessage(room, msg, deps) {
-  switch (msg.type) {
-    case "authenticated":
-      room.myUserId = msg.userId;
-      deps.log({ event: "collab_authenticated", roomId: room.roomId, userId: msg.userId });
-      break;
-    case "participants-list":
-      handleParticipantsList(room, msg.participants, deps);
-      break;
-    case "participant-joined":
-      handleParticipantJoined(room, msg.participant, deps);
-      break;
-    case "participant-left":
-      handleParticipantLeft(room, { userId: msg.userId, connectionId: msg.connectionId }, deps);
-      break;
-    case "webrtc-offer":
-      handleWebrtcSignaling(room, "offer", msg.targetUserId, msg.generationId, msg.offer, deps);
-      break;
-    case "webrtc-answer":
-      handleWebrtcSignaling(room, "answer", msg.targetUserId, msg.generationId, msg.answer, deps);
-      break;
-    case "webrtc-ice":
-      handleWebrtcSignaling(room, "ice", msg.targetUserId, msg.generationId, msg.candidate, deps);
-      break;
-    case "ice-servers":
-      room.peerManager.updateIceServers(msg.iceServers);
-      deps.log({ event: "collab_ice_servers", roomId: room.roomId, count: msg.iceServers.length });
-      break;
-    case "error":
-      deps.log({ event: "collab_room_error", roomId: room.roomId, message: msg.message });
-      break;
-    default:
-      assertNever5(msg);
-  }
-}
-function registerCollabParticipant(room, userId, role, displayName, deps) {
-  const peerId = namespacePeerId(room.roomId, userId);
-  deps.peerRoleRegistry.registerCollabPeer(peerId, role, userId, displayName, room.taskId);
-}
-function initiateOfferToParticipant(room, remoteUserId, deps) {
-  if (!room.myUserId) return;
-  room.knownPeers.add(remoteUserId);
-  deps.log({ event: "collab_initiating_offer", roomId: room.roomId, target: remoteUserId });
-  const peerId = namespacePeerId(room.roomId, remoteUserId);
-  room.peerManager.initiateOffer(peerId).catch((err3) => {
-    deps.log({ event: "collab_offer_initiate_failed", roomId: room.roomId, error: String(err3) });
-  });
-}
-function createCollabRoomManager(deps) {
-  const rooms = /* @__PURE__ */ new Map();
-  async function leave(roomId) {
-    const room = rooms.get(roomId);
-    if (!room) return;
-    deps.log({ event: "collab_leaving", roomId });
-    clearTimeout(room.expiryTimer);
-    room.unsubMessage();
-    room.unsubState();
-    for (const userId of room.knownPeers) {
-      deps.peerRoleRegistry.unregisterPeer(namespacePeerId(roomId, userId));
-    }
-    const destroyPromise = room.collabRepoHandle?.destroy();
-    room.peerManager.destroy();
-    room.connection.disconnect();
-    const leftTaskId = room.taskId;
-    rooms.delete(roomId);
-    deps.onRoomStateChanged?.(leftTaskId);
-    if (destroyPromise) {
-      await destroyPromise.catch((err3) => {
-        deps.log({
-          event: "collab_repo_destroy_failed",
-          roomId,
-          error: err3 instanceof Error ? err3.message : String(err3)
-        });
-      });
-    }
-  }
-  return {
-    joinRoom(config) {
-      const { roomId, taskId, token, expiresAt, signalingBaseUrl, userToken, machineId } = config;
-      const existing = rooms.get(roomId);
-      if (existing) {
-        const existingState = existing.connection.getState();
-        if (existing.taskId === taskId && (existingState === "connected" || existingState === "connecting")) {
-          deps.log({ event: "collab_join_dedup", roomId, state: existingState });
-          return {
-            roomId,
-            taskId,
-            async destroy() {
-              await leave(roomId);
-            }
-          };
-        }
-        deps.log({ event: "collab_replacing", roomId });
-        leave(roomId).catch((err3) => {
-          deps.log({
-            event: "collab_replace_leave_failed",
-            roomId,
-            error: err3 instanceof Error ? err3.message : String(err3)
-          });
-        });
-      }
-      const wsUrl = new URL(signalingBaseUrl);
-      wsUrl.pathname = ROUTES.WS_COLLAB.replace(":roomId", roomId);
-      wsUrl.searchParams.set("token", token);
-      wsUrl.searchParams.set("userToken", userToken);
-      wsUrl.searchParams.set("clientType", "agent");
-      wsUrl.searchParams.set("machineId", machineId);
-      const connection = new CollabRoomConnection({
-        url: wsUrl.toString(),
-        maxRetries: -1,
-        initialDelayMs: 1e3,
-        maxDelayMs: 3e4,
-        backoffMultiplier: 2
+        requestId,
+        error: err3 instanceof Error ? err3.message : String(err3)
       });
-      const collabRepoHandle = createCollabRepo(
-        deps.personalRepo,
-        taskId,
-        roomId,
-        { plan: deps.planEpoch, canvas: deps.canvasEpoch },
-        deps.peerRoleRegistry
+      rawSend(
+        JSON.stringify({
+          type: "upload-error",
+          requestId,
+          error: err3 instanceof Error ? err3.message : "Upload failed"
+        })
       );
-      const peerManager = deps.createPeerManagerForRoom(
-        roomId,
-        connection,
-        taskId,
-        collabRepoHandle.webrtcAdapter
+    });
+  }
+  async function handleDownloadRequest(requestId, assetId) {
+    try {
+      const { data, meta } = await assetStore.read(assetId);
+      rawSend(
+        JSON.stringify({
+          type: "download-head",
+          requestId,
+          mimeType: meta.mimeType,
+          totalBytes: data.byteLength
+        })
       );
-      const handle = {
-        roomId,
-        taskId,
-        async destroy() {
-          await leave(roomId);
-        }
-      };
-      const delayMs = expiresAt - Date.now();
-      if (delayMs <= 0 || !Number.isFinite(delayMs)) {
-        deps.log({ event: "collab_expired", roomId, expiresAt });
-        peerManager.destroy();
-        collabRepoHandle.destroy().catch((err3) => {
-          deps.log({
-            event: "collab_repo_destroy_failed",
-            roomId,
-            error: err3 instanceof Error ? err3.message : String(err3)
-          });
+      const shell = createDownloadShell(requestId);
+      downloadShells.set(requestId, shell);
+      await shell.initialize();
+      await shell.setConnected(true);
+      const bytes = new Uint8Array(data);
+      let chunkIndex = 0;
+      let yieldCounter = 0;
+      for (let offset = 0; offset < bytes.byteLength; offset += ASSET_CHUNK_SIZE) {
+        const end = Math.min(offset + ASSET_CHUNK_SIZE, bytes.byteLength);
+        const chunk = bytes.subarray(offset, end);
+        await shell.send({
+          kind: "download-chunk",
+          requestId,
+          chunkIndex,
+          data: encodeChunk(chunk)
         });
-        return handle;
+        chunkIndex++;
+        yieldCounter++;
+        if (yieldCounter % YIELD_EVERY_CHUNKS === 0) {
+          await new Promise((r) => setTimeout(r, 0));
+        }
       }
-      const safeDelayMs = Math.min(delayMs, 2147483647);
-      const room = {
-        roomId,
+      rawSend(JSON.stringify({ type: "download-done", requestId }));
+      log({ event: "asset_download_complete", requestId, assetId, size: data.byteLength });
+      setTimeout(() => downloadShells.delete(requestId), UPLOAD_TIMEOUT_MS);
+    } catch (err3) {
+      downloadShells.delete(requestId);
+      const { event, reason } = classifyDownloadError(assetId, err3);
+      log({ event, requestId, assetId, error: reason });
+      rawSend(
+        JSON.stringify({
+          type: "download-error",
+          requestId,
+          error: err3 instanceof Error ? err3.message : "Download failed"
+        })
+      );
+    }
+  }
+  async function handleDeliverableFileRequest(requestId, taskId, deliverableId) {
+    const resolved = await resolveDeliverableFile(deliverableStore, taskId, deliverableId);
+    if (resolved.kind === "error") {
+      log({
+        event: resolved.event,
+        requestId,
         taskId,
-        connection,
-        peerManager,
-        collabRepoHandle,
-        myUserId: null,
-        knownPeers: /* @__PURE__ */ new Set(),
-        participants: [],
-        connectionIdByUser: /* @__PURE__ */ new Map(),
-        expiresAt,
-        generation: 0,
-        expiryTimer: setTimeout(() => {
-          deps.log({ event: "collab_token_expired", roomId });
-          leave(roomId).catch((err3) => {
-            deps.log({
-              event: "collab_expiry_leave_failed",
-              roomId,
-              error: err3 instanceof Error ? err3.message : String(err3)
-            });
-          });
-        }, safeDelayMs),
-        unsubMessage: () => {
-        },
-        unsubState: () => {
-        }
-      };
-      rooms.set(roomId, room);
-      room.unsubMessage = connection.onMessage((msg) => {
-        handleCollabRoomMessage(room, msg, deps);
+        deliverableId,
+        ...resolved.logExtras
       });
-      room.unsubState = connection.onStateChange((state) => {
-        deps.log({ event: "collab_state_change", roomId, state });
-        if (state === "disconnected" || state === "error") {
-          room.peerManager.destroy();
-          room.peerManager = deps.createPeerManagerForRoom(
-            roomId,
-            connection,
-            taskId,
-            room.collabRepoHandle?.webrtcAdapter ?? collabRepoHandle.webrtcAdapter
-          );
-          room.myUserId = null;
-          room.knownPeers.clear();
-          room.connectionIdByUser.clear();
-        }
+      rawSend(JSON.stringify({ type: "download-error", requestId, error: "" }));
+      return;
+    }
+    if (allowedTaskId !== null && resolved.recordTaskId !== allowedTaskId) {
+      log({
+        event: "deliverable_file_task_scope_mismatch",
+        level: "warn",
+        requestId,
+        allowedTaskId,
+        requestedTaskId: taskId
       });
-      connection.connect();
-      deps.log({ event: "collab_joining", roomId, taskId });
-      bumpAndNotify(room, deps);
-      return handle;
-    },
-    async leaveRoom(roomId) {
-      await leave(roomId);
-    },
-    getParticipantsForTask(taskId) {
-      for (const room of rooms.values()) {
-        if (room.taskId === taskId) {
-          return room.participants.filter((p2) => p2.userId !== room.myUserId).map((p2) => ({ name: p2.username, role: p2.role }));
+      rawSend(JSON.stringify({ type: "download-error", requestId, error: "" }));
+      return;
+    }
+    const { filePath, mimeType } = resolved;
+    try {
+      const data = await fsReadFile(filePath);
+      rawSend(
+        JSON.stringify({
+          type: "download-head",
+          requestId,
+          mimeType,
+          totalBytes: data.byteLength
+        })
+      );
+      const shell = createDownloadShell(requestId);
+      downloadShells.set(requestId, shell);
+      await shell.initialize();
+      await shell.setConnected(true);
+      const bytes = new Uint8Array(data);
+      let chunkIndex = 0;
+      let yieldCounter = 0;
+      for (let offset = 0; offset < bytes.byteLength; offset += ASSET_CHUNK_SIZE) {
+        const end = Math.min(offset + ASSET_CHUNK_SIZE, bytes.byteLength);
+        const chunk = bytes.subarray(offset, end);
+        await shell.send({
+          kind: "download-chunk",
+          requestId,
+          chunkIndex,
+          data: encodeChunk(chunk)
+        });
+        chunkIndex++;
+        yieldCounter++;
+        if (yieldCounter % YIELD_EVERY_CHUNKS === 0) {
+          await new Promise((r) => setTimeout(r, 0));
         }
       }
-      return [];
-    },
-    listActiveTaskIds() {
-      const ids = [];
-      for (const room of rooms.values()) ids.push(room.taskId);
-      return ids;
-    },
-    getStateForTask(taskId) {
-      for (const room of rooms.values()) {
-        if (room.taskId !== taskId) continue;
-        const owner = room.participants.find((p2) => p2.role === "owner");
-        return {
-          roomId: room.roomId,
-          taskId: room.taskId,
-          ownerId: owner?.userId ?? "",
-          participants: room.participants,
-          expiresAt: room.expiresAt,
-          generation: room.generation
-        };
-      }
-      return null;
-    },
-    async destroy() {
-      await Promise.all([...rooms.keys()].map((roomId) => leave(roomId)));
+      rawSend(JSON.stringify({ type: "download-done", requestId }));
+      log({
+        event: "deliverable_file_download_complete",
+        requestId,
+        deliverableId,
+        size: data.byteLength
+      });
+      setTimeout(() => downloadShells.delete(requestId), UPLOAD_TIMEOUT_MS);
+    } catch (err3) {
+      downloadShells.delete(requestId);
+      const reason = err3 instanceof Error ? err3.message : String(err3);
+      log({
+        event: "deliverable_file_download_failed",
+        level: "warn",
+        requestId,
+        deliverableId,
+        error: reason
+      });
+      rawSend(JSON.stringify({ type: "download-error", requestId, error: "" }));
+    }
+  }
+  dc.onmessage = (event) => {
+    if (typeof event.data === "string") {
+      const data = event.data;
+      receiveQueue = receiveQueue.then(() => handleTextMessage(data)).catch((err3) => {
+        log({
+          event: "asset_channel_handler_error",
+          error: err3 instanceof Error ? err3.message : String(err3)
+        });
+      });
+    }
+  };
+  dc.onclose = () => {
+    for (const upload of pendingUploads.values()) clearTimeout(upload.timer);
+    pendingUploads.clear();
+    downloadShells.clear();
+    guardedText.dispose();
+    receiveQueue = Promise.resolve();
+  };
+  return {
+    dispose() {
+      dc.onmessage = null;
+      dc.onclose = null;
+      for (const upload of pendingUploads.values()) clearTimeout(upload.timer);
+      pendingUploads.clear();
+      downloadShells.clear();
+      guardedText.dispose();
+      receiveQueue = Promise.resolve();
     }
   };
 }
@@ -34333,19 +34861,19 @@ function wireThreadErrorFallback(daemon, dc, taskId, threadId, channelId, log) {
 }
 
 // src/services/terminal-handler.ts
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 
 // src/shared/pty-manager.ts
 import { accessSync, chmodSync, constants as constants2, createWriteStream } from "fs";
 import { rename as rename13, unlink as unlink8 } from "fs/promises";
 import { createRequire as createRequire2 } from "module";
-import { dirname as dirname19, resolve as resolve7 } from "path";
+import { dirname as dirname20, resolve as resolve7 } from "path";
 import * as pty from "node-pty";
 function ensureSpawnHelperExecutable() {
   if (globalThis.process.platform === "win32") return;
   try {
     const req = createRequire2(import.meta.url);
-    const nodePtyDir = dirname19(req.resolve("node-pty/package.json"));
+    const nodePtyDir = dirname20(req.resolve("node-pty/package.json"));
     const spawnHelper = resolve7(
       nodePtyDir,
       "prebuilds",
@@ -34614,7 +35142,7 @@ function createPtyManager() {
 // src/services/terminal-handler.ts
 var MAX_PTYS_DEFAULT = 20;
 function terminalLogPathFor(dir, terminalId) {
-  return join39(dir, `${terminalId}.log`);
+  return join40(dir, `${terminalId}.log`);
 }
 function handleTerminalChannel(taskId, terminalId, cwd, send, log, deps) {
   const maxPtys = deps.maxPtys ?? MAX_PTYS_DEFAULT;
@@ -34814,13 +35342,15 @@ function buildCollabRoomManager(deps) {
     fileWatcherPool,
     terminalPtys,
     terminalLogsDir,
-    housekeepingBarrier
+    housekeepingBarrier,
+    collabHostingStore
   } = deps;
   let managerRef = null;
   const emitCollabRoomState = (taskId) => {
     const mgr2 = managerRef;
     if (!mgr2) return;
     const state = mgr2.getStateForTask(taskId);
+    if (!shouldBroadcastRoomState(state)) return;
     daemon.taskManager.broadcastControl({
       type: "collab_room_state",
       taskId,
@@ -35216,6 +35746,7 @@ function buildCollabRoomManager(deps) {
     onRoomStateChanged: (taskId) => {
       emitCollabRoomState(taskId);
     },
+    collabHostingStore,
     log: logAdapter
   });
   managerRef = mgr;
@@ -35225,7 +35756,7 @@ function buildCollabRoomManager(deps) {
 // src/services/serve-factory.ts
 import { randomUUID as randomUUID25 } from "crypto";
 import { mkdir as mkdir36 } from "fs/promises";
-import { join as join78 } from "path";
+import { join as join79 } from "path";
 
 // src/shared/capabilities/cursor-boot-auth.ts
 async function mergeCursorAuthFromVault(caps, detect, log) {
@@ -35266,12 +35797,12 @@ async function mergeCursorAuthFromVault(caps, detect, log) {
 
 // src/shared/capabilities/cursor-hook-shim-path.ts
 import { statSync as statSync4 } from "fs";
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function getCursorHookShimPath() {
   const resourcesPath = Reflect.get(process, "resourcesPath");
   if (typeof resourcesPath === "string" && resourcesPath.length > 0) {
-    return join40(resourcesPath, "daemon", "cursor-hook-shim.js");
+    return join41(resourcesPath, "daemon", "cursor-hook-shim.js");
   }
   return fileURLToPath2(new URL("./cursor-hook-shim.js", import.meta.url));
 }
@@ -35504,9 +36035,9 @@ function resolveRuntimeAuthIdentity(runtimeAuth, runtimeId) {
 }
 
 // src/shared/capabilities/spinner-verbs-reader.ts
-import { readFile as readFile21 } from "fs/promises";
+import { readFile as readFile22 } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { join as join41 } from "path";
+import { join as join42 } from "path";
 var ClaudeSpinnerVerbsSchema = external_exports.object({
   mode: external_exports.enum(["append", "replace"]),
   verbs: external_exports.array(external_exports.string())
@@ -35531,12 +36062,12 @@ function toPersistedVerbs(resolved, defaults) {
   return resolved.every((v2, i) => v2 === defaults[i]) ? [] : [...resolved];
 }
 async function readSpinnerVerbs() {
-  const claudeDir = join41(homedir6(), ".claude");
-  const paths = [join41(claudeDir, "settings.json"), join41(claudeDir, "settings.local.json")];
+  const claudeDir = join42(homedir6(), ".claude");
+  const paths = [join42(claudeDir, "settings.json"), join42(claudeDir, "settings.local.json")];
   const parsed = await Promise.all(
     paths.map(async (p2) => {
       try {
-        const raw = await readFile21(p2, "utf-8");
+        const raw = await readFile22(p2, "utf-8");
         const json = JSON.parse(raw);
         if (json === null || typeof json !== "object") return null;
         const field2 = Reflect.get(json, "spinnerVerbs");
@@ -35573,8 +36104,8 @@ async function reimportSpinnerVerbs(store, log) {
 }
 
 // src/shared/mcp/oauth-state-store.ts
-import { readFile as readFile22 } from "fs/promises";
-import { join as join42 } from "path";
+import { readFile as readFile23 } from "fs/promises";
+import { join as join43 } from "path";
 import {
   OAuthClientInformationFullSchema as OAuthClientInformationFullSchema2,
   OAuthClientInformationSchema as OAuthClientInformationSchema2,
@@ -35620,7 +36151,7 @@ var MCPOAuthStateStore = class {
     this.#shipyardHome = shipyardHome;
   }
   #filePath() {
-    return join42(this.#shipyardHome, STATE_FILE);
+    return join43(this.#shipyardHome, STATE_FILE);
   }
   #lockPath() {
     return `${this.#filePath()}.lock`;
@@ -35628,7 +36159,7 @@ var MCPOAuthStateStore = class {
   /** Always reads the state map from disk (never the cache). */
   async #readFreshMap() {
     try {
-      const raw = await readFile22(this.#filePath(), "utf-8");
+      const raw = await readFile23(this.#filePath(), "utf-8");
       const parsed = StateMapSchema.safeParse(JSON.parse(raw));
       return parsed.success ? parsed.data : {};
     } catch {
@@ -35718,12 +36249,12 @@ function getShipyardSubagentCatalog() {
 }
 
 // src/services/bootstrap/rehydrate.ts
-import { readFile as readFile24, rename as rename15, writeFile as writeFile16 } from "fs/promises";
-import { join as join44 } from "path";
+import { readFile as readFile25, rename as rename15, writeFile as writeFile16 } from "fs/promises";
+import { join as join45 } from "path";
 
 // src/services/collab/collab-queue-persistence.ts
-import { appendFile as appendFile2, mkdir as mkdir15, readdir as readdir15, readFile as readFile23, rename as rename14, rm as rm9, writeFile as writeFile15 } from "fs/promises";
-import { join as join43 } from "path";
+import { appendFile as appendFile2, mkdir as mkdir16, readdir as readdir15, readFile as readFile24, rename as rename14, rm as rm9, writeFile as writeFile15 } from "fs/promises";
+import { join as join44 } from "path";
 var PersistedQueueEntrySchema = external_exports.object({
   content: external_exports.array(ContentBlockSchema),
   settings: DaemonSettingsSchema.optional(),
@@ -35747,12 +36278,12 @@ function parsePersistedLine(line) {
   };
 }
 function buildCollabQueuePersistence(dataDir) {
-  const queuesDir = join43(dataDir, "collab-queues");
+  const queuesDir = join44(dataDir, "collab-queues");
   function queuePath(queueKey) {
-    return join43(queuesDir, `${queueKey}.jsonl`);
+    return join44(queuesDir, `${queueKey}.jsonl`);
   }
   async function ensureDir() {
-    await mkdir15(queuesDir, { recursive: true });
+    await mkdir16(queuesDir, { recursive: true });
   }
   const writeChain = /* @__PURE__ */ new Map();
   async function chained(queueKey, work) {
@@ -35777,7 +36308,7 @@ function buildCollabQueuePersistence(dataDir) {
     async read(queueKey) {
       let raw;
       try {
-        raw = await readFile23(queuePath(queueKey), "utf-8");
+        raw = await readFile24(queuePath(queueKey), "utf-8");
       } catch (err3) {
         if (isEnoent(err3)) return [];
         throw err3;
@@ -35842,7 +36373,7 @@ function buildCollabQueuePersistence(dataDir) {
       }
       for (const name of names) {
         if (!name.includes(".tmp-")) continue;
-        await rm9(join43(queuesDir, name), { force: true }).catch(() => {
+        await rm9(join44(queuesDir, name), { force: true }).catch(() => {
         });
       }
     }
@@ -36104,11 +36635,11 @@ async function readRawTasksEnvelope(tasksPath) {
   let raw;
   let fromMigrated = false;
   try {
-    raw = await readFile24(tasksPath, "utf-8");
+    raw = await readFile25(tasksPath, "utf-8");
   } catch (err3) {
     if (!isEnoent(err3)) throw err3;
     try {
-      raw = await readFile24(`${tasksPath}.migrated`, "utf-8");
+      raw = await readFile25(`${tasksPath}.migrated`, "utf-8");
       fromMigrated = true;
     } catch (err22) {
       if (isEnoent(err22)) return null;
@@ -36161,7 +36692,7 @@ async function stripPinnedFieldFromTasksFile(tasksPath, envelope, records) {
   }
 }
 async function migratePinnedToFavoriteTasks(dataDir, userSettingsStore, log) {
-  const tasksPath = join44(dataDir, "tasks.json");
+  const tasksPath = join45(dataDir, "tasks.json");
   const parsed = await readRawTasksEnvelope(tasksPath);
   if (!parsed) return;
   const { records, envelope, fromMigrated } = parsed;
@@ -36276,8 +36807,8 @@ async function sweepStaleTasks(taskStateStore, taskManager, log) {
 }
 
 // src/services/bootstrap/update-status.ts
-import { readFile as readFile25, unlink as unlink9 } from "fs/promises";
-import { join as join45 } from "path";
+import { readFile as readFile26, unlink as unlink9 } from "fs/promises";
+import { join as join46 } from "path";
 var UPDATE_STATUS_FILENAME = "update-status.json";
 var RAW_LOG_MAX_CHARS = 500;
 var UpdateStatusSchema = external_exports.object({
@@ -36290,10 +36821,10 @@ var UpdateStatusSchema = external_exports.object({
   rolledBack: external_exports.boolean()
 });
 async function readAndClearUpdateStatus(shipyardHome, log) {
-  const path5 = join45(shipyardHome, UPDATE_STATUS_FILENAME);
+  const path5 = join46(shipyardHome, UPDATE_STATUS_FILENAME);
   let raw;
   try {
-    raw = await readFile25(path5, "utf-8");
+    raw = await readFile26(path5, "utf-8");
   } catch (err3) {
     if (isEnoent(err3)) return null;
     log.warn({ err: err3, path: path5 }, "failed to read update-status.json");
@@ -36377,11 +36908,11 @@ function wireUpdateStatusForwarding(report, sink2, onMessage, log) {
 
 // src/services/bootstrap/updates-cleanup.ts
 import { readdir as readdir16, rm as rm10, stat as stat13, unlink as unlink11 } from "fs/promises";
-import { join as join47 } from "path";
+import { join as join48 } from "path";
 
 // src/services/bootstrap/self-update-lock.ts
-import { mkdir as mkdir16, readFile as readFile26, stat as stat12, unlink as unlink10, writeFile as writeFile17 } from "fs/promises";
-import { dirname as dirname20, join as join46 } from "path";
+import { mkdir as mkdir17, readFile as readFile27, stat as stat12, unlink as unlink10, writeFile as writeFile17 } from "fs/promises";
+import { dirname as dirname21, join as join47 } from "path";
 var LOCK_FILENAME = ".lock";
 var STALE_LOCK_MS = 10 * 60 * 1e3;
 var LockFileSchema = external_exports.object({
@@ -36389,7 +36920,7 @@ var LockFileSchema = external_exports.object({
   startedAt: external_exports.number()
 });
 function lockPath(shipyardHome) {
-  return join46(shipyardHome, "updates", LOCK_FILENAME);
+  return join47(shipyardHome, "updates", LOCK_FILENAME);
 }
 function isStaleLock(lock, now, isProcessAlive2) {
   const age = now - lock.startedAt;
@@ -36401,7 +36932,7 @@ async function readLockFile(shipyardHome) {
   const path5 = lockPath(shipyardHome);
   let raw;
   try {
-    raw = await readFile26(path5, "utf-8");
+    raw = await readFile27(path5, "utf-8");
   } catch {
     return null;
   }
@@ -36418,7 +36949,7 @@ async function readLockFileWithOutcome(shipyardHome) {
   const path5 = lockPath(shipyardHome);
   let raw;
   try {
-    raw = await readFile26(path5, "utf-8");
+    raw = await readFile27(path5, "utf-8");
   } catch (err3) {
     if (isEnoent(err3)) return { kind: "absent" };
     return { kind: "read-error", err: err3 };
@@ -36436,7 +36967,7 @@ async function readLockFileWithOutcome(shipyardHome) {
 async function unlinkStaleLock(path5, expected) {
   let current;
   try {
-    const raw = await readFile26(path5, "utf-8");
+    const raw = await readFile27(path5, "utf-8");
     const parsed = LockFileSchema.safeParse(JSON.parse(raw));
     current = parsed.success ? parsed.data : null;
   } catch (err3) {
@@ -36473,7 +37004,7 @@ async function resolveEexist(shipyardHome, path5, ownerPid, now, isProcessAlive2
 }
 async function tryAcquireLockExclusive(shipyardHome, pid, now, isProcessAlive2) {
   const path5 = lockPath(shipyardHome);
-  await mkdir16(dirname20(path5), { recursive: true });
+  await mkdir17(dirname21(path5), { recursive: true });
   const body = JSON.stringify({ pid, startedAt: now() });
   while (true) {
     try {
@@ -36512,7 +37043,7 @@ async function cleanupUpdatesDir(shipyardHome, deps = {}) {
   const now = deps.now ?? Date.now;
   const isProcessAlive2 = deps.isProcessAlive ?? defaultIsProcessAlive;
   const log = deps.log;
-  const updatesDir = join47(shipyardHome, "updates");
+  const updatesDir = join48(shipyardHome, "updates");
   const empty = {
     tarballsKept: [],
     tarballsDeleted: [],
@@ -36636,7 +37167,7 @@ async function sortByMtimeDesc(baseDir, names, log) {
   const rows = [];
   for (const name of names) {
     try {
-      const s2 = await stat13(join47(baseDir, name));
+      const s2 = await stat13(join48(baseDir, name));
       rows.push({ name, mtimeMs: s2.mtimeMs });
     } catch (err3) {
       log?.info({ err: err3, entry: name }, "updates cleanup: stat failed, skipping entry");
@@ -36649,7 +37180,7 @@ async function filterOlderThan(baseDir, names, nowMs, thresholdMs, log) {
   const out = [];
   for (const name of names) {
     try {
-      const s2 = await stat13(join47(baseDir, name));
+      const s2 = await stat13(join48(baseDir, name));
       if (nowMs - s2.mtimeMs > thresholdMs) {
         out.push(name);
       }
@@ -36663,7 +37194,7 @@ async function deleteFiles(baseDir, names, log) {
   const deleted = [];
   for (const name of names) {
     try {
-      await unlink11(join47(baseDir, name));
+      await unlink11(join48(baseDir, name));
       deleted.push(name);
     } catch (err3) {
       if (isEnoent(err3)) {
@@ -36679,7 +37210,7 @@ async function deleteDirs(baseDir, names, log) {
   const deleted = [];
   for (const name of names) {
     try {
-      await rm10(join47(baseDir, name), { recursive: true, force: true });
+      await rm10(join48(baseDir, name), { recursive: true, force: true });
       deleted.push(name);
     } catch (err3) {
       log?.info({ err: err3, entry: name }, "updates cleanup: rm -rf failed");
@@ -36688,7 +37219,7 @@ async function deleteDirs(baseDir, names, log) {
   return deleted;
 }
 async function maybeClearLock(shipyardHome, nowMs, isProcessAlive2, log) {
-  const lockFilePath = join47(shipyardHome, "updates", LOCK_FILENAME);
+  const lockFilePath = join48(shipyardHome, "updates", LOCK_FILENAME);
   const outcome = await readLockFileWithOutcome(shipyardHome);
   switch (outcome.kind) {
     case "absent":
@@ -37992,8 +38523,8 @@ function wireDevServersAndTerminalsResolvers(deps) {
 }
 
 // src/services/file-resource-resolver.ts
-import { readFile as readFile27, stat as stat14 } from "fs/promises";
-import { basename as basename8, join as join48, normalize as normalize4, sep as sep2 } from "path";
+import { readFile as readFile28, stat as stat14 } from "fs/promises";
+import { basename as basename8, join as join49, normalize as normalize4, sep as sep2 } from "path";
 var MAX_FILE_SIZE = 10 * 1024 * 1024;
 var MIME_BY_EXT2 = {
   ".ts": "text/typescript",
@@ -38062,7 +38593,7 @@ function createFileResourceResolver(deps) {
       const { taskId, relativePath } = parseFileUri2(uri);
       const cwd = deps.getTaskCwd(taskId) ?? deps.workspaceRoot;
       const normalizedCwd = normalize4(cwd);
-      const absolutePath = normalize4(join48(cwd, relativePath));
+      const absolutePath = normalize4(join49(cwd, relativePath));
       const cwdPrefix = normalizedCwd.endsWith(sep2) ? normalizedCwd : `${normalizedCwd}${sep2}`;
       if (!absolutePath.startsWith(cwdPrefix) && absolutePath !== normalizedCwd) {
         throw new Error(`Path traversal rejected: ${relativePath}`);
@@ -38080,14 +38611,14 @@ function createFileResourceResolver(deps) {
         };
       }
       if (isImageExtension(absolutePath)) {
-        const buffer2 = await readFile27(absolutePath);
+        const buffer2 = await readFile28(absolutePath);
         return {
           uri,
           mimeType: guessMimeType(absolutePath),
           blob: buffer2.toString("base64")
         };
       }
-      const buffer = await readFile27(absolutePath);
+      const buffer = await readFile28(absolutePath);
       if (looksLikeBinary(buffer)) {
         return {
           uri,
@@ -38106,8 +38637,8 @@ function createFileResourceResolver(deps) {
 
 // src/services/git-checkpoint.ts
 import { execFile as execFileCb2 } from "child_process";
-import { readFile as readFile28, stat as stat15, unlink as unlink12, writeFile as writeFile18 } from "fs/promises";
-import { join as join49 } from "path";
+import { readFile as readFile29, stat as stat15, unlink as unlink12, writeFile as writeFile18 } from "fs/promises";
+import { join as join50 } from "path";
 import { promisify as promisify8 } from "util";
 var execFile9 = promisify8(execFileCb2);
 var NOT_A_GIT_REPO = "Not a git repository";
@@ -38119,10 +38650,10 @@ async function resolveGitPaths(repoDir, taskId) {
   try {
     const { stdout } = await execFile9("git", ["rev-parse", "--git-dir"], { cwd: repoDir });
     const gitDir = stdout.trim();
-    const absoluteGitDir = gitDir.startsWith("/") ? gitDir : join49(repoDir, gitDir);
+    const absoluteGitDir = gitDir.startsWith("/") ? gitDir : join50(repoDir, gitDir);
     return {
       gitDir: absoluteGitDir,
-      shadowIndex: join49(absoluteGitDir, `shipyard-index-${taskId}`)
+      shadowIndex: join50(absoluteGitDir, `shipyard-index-${taskId}`)
     };
   } catch {
     return null;
@@ -38217,7 +38748,7 @@ async function rewindToCheckpointImpl(repoDir, taskId, turnNo) {
     const untrackedFiles = untrackedRaw.trim().split("\n").filter((f2) => f2.length > 0);
     for (const file of untrackedFiles) {
       try {
-        const fullPath = join49(repoDir, file);
+        const fullPath = join50(repoDir, file);
         const s2 = await stat15(fullPath);
         if (s2.isFile()) {
           await unlink12(fullPath);
@@ -38484,7 +39015,7 @@ async function revertSingleFile(repoDir, file, restoreCommit, mode) {
   const isDeletedByAgent = file.status === "deleted";
   const shouldDelete = mode === "revert" && isAddedByAgent || mode === "unrevert" && isDeletedByAgent;
   if (shouldDelete) {
-    await unlink12(join49(repoDir, file.path)).catch((err3) => {
+    await unlink12(join50(repoDir, file.path)).catch((err3) => {
       if (!isEnoent(err3)) throw err3;
     });
     await execFile9("git", ["reset", "HEAD", "--", file.path], { cwd: repoDir }).catch(() => {
@@ -38496,7 +39027,7 @@ async function revertSingleFile(repoDir, file, restoreCommit, mode) {
     maxBuffer: 10 * 1024 * 1024,
     encoding: "buffer"
   });
-  await writeFile18(join49(repoDir, file.path), stdout);
+  await writeFile18(join50(repoDir, file.path), stdout);
   await execFile9("git", ["reset", "HEAD", "--", file.path], { cwd: repoDir }).catch(() => {
   });
   return true;
@@ -38589,7 +39120,7 @@ async function diffCheckpointToWorkingTreeImpl(repoDir, taskId, fromTurnNo, scop
         if (!line || statusMap.has(line)) continue;
         let ins = 0;
         try {
-          ins = countLines(await readFile28(join49(repoDir, line), "utf-8"));
+          ins = countLines(await readFile29(join50(repoDir, line), "utf-8"));
         } catch {
         }
         entries.push({ path: line, status: "added", insertions: ins, deletions: 0 });
@@ -38609,7 +39140,7 @@ async function getFileVsWorkingTreeImpl(repoDir, taskId, fromTurnNo, filePath) {
   if (from === "error") return null;
   let modifiedContent;
   try {
-    modifiedContent = await readFile28(join49(repoDir, filePath), "utf-8");
+    modifiedContent = await readFile29(join50(repoDir, filePath), "utf-8");
   } catch {
     modifiedContent = "";
   }
@@ -38706,8 +39237,8 @@ function unregisterSubprocessEpoch(taskId, registry = subprocessEpochs) {
 
 // src/services/harness/deliverable-server.ts
 import { randomUUID as randomUUID12 } from "crypto";
-import { copyFile, rm as fsRm, stat as fsStat3, mkdir as mkdir17 } from "fs/promises";
-import { basename as basename9, extname as extname2, join as join50, resolve as resolve8, sep as sep3 } from "path";
+import { copyFile, rm as fsRm, stat as fsStat3, mkdir as mkdir18 } from "fs/promises";
+import { basename as basename9, extname as extname2, join as join51, resolve as resolve8, sep as sep3 } from "path";
 var TOOL_DESCRIPTION2 = [
   "Register a proof-of-work deliverable for this task \u2014 proof a reviewer cannot get from the diff alone.",
   "",
@@ -38771,7 +39302,7 @@ var RegisterDeliverableInput = {
 };
 var COPY_MAX_BYTES = 50 * 1024 * 1024;
 function isInternedFile(dataDir, filePath) {
-  const internBase = resolve8(join50(dataDir, "deliverable-files")) + sep3;
+  const internBase = resolve8(join51(dataDir, "deliverable-files")) + sep3;
   return resolve8(filePath).startsWith(internBase);
 }
 async function internDeliverableFile(deliverableId, taskId, filePath, storedSizeBytes, dataDir, prevInternedPath) {
@@ -38795,10 +39326,10 @@ async function internDeliverableFile(deliverableId, taskId, filePath, storedSize
     };
   }
   const ext = extname2(filePath);
-  const destDir = join50(dataDir, "deliverable-files", taskId);
-  const destPath = join50(destDir, `${deliverableId}${ext}`);
+  const destDir = join51(dataDir, "deliverable-files", taskId);
+  const destPath = join51(destDir, `${deliverableId}${ext}`);
   try {
-    await mkdir17(destDir, { recursive: true });
+    await mkdir18(destDir, { recursive: true });
     await copyFile(filePath, destPath);
   } catch (err3) {
     return {
@@ -39221,8 +39752,8 @@ function createDeliverableTools(ctx) {
 }
 
 // src/services/harness/plugin-server.ts
-import { mkdir as mkdir18, writeFile as writeFile19 } from "fs/promises";
-import { join as join51 } from "path";
+import { mkdir as mkdir19, writeFile as writeFile19 } from "fs/promises";
+import { join as join52 } from "path";
 
 // src/services/harness/sandbox-docs.ts
 var SANDBOX_HTML_RULES = `## HTML Rules
@@ -39851,14 +40382,14 @@ ${addendum}`;
             events: input.events,
             provideResources: input.provideResources
           });
-          const pluginDir = join51(ctx.pluginsDir, input.pluginId);
-          await mkdir18(pluginDir, { recursive: true });
-          await writeFile19(join51(pluginDir, "template.html"), input.template, "utf-8");
+          const pluginDir = join52(ctx.pluginsDir, input.pluginId);
+          await mkdir19(pluginDir, { recursive: true });
+          await writeFile19(join52(pluginDir, "template.html"), input.template, "utf-8");
           if (input.handler) {
-            await writeFile19(join51(pluginDir, "handler.mjs"), input.handler, "utf-8");
+            await writeFile19(join52(pluginDir, "handler.mjs"), input.handler, "utf-8");
           }
           await writeFile19(
-            join51(pluginDir, "plugin.json"),
+            join52(pluginDir, "plugin.json"),
             JSON.stringify(manifest, null, 2),
             "utf-8"
           );
@@ -40595,7 +41126,7 @@ function errorResult(message) {
 }
 
 // src/services/harness/visualize-server.ts
-import { readFile as readFile29 } from "fs/promises";
+import { readFile as readFile30 } from "fs/promises";
 import * as net from "net";
 
 // src/services/harness/html-validator.ts
@@ -49358,7 +49889,7 @@ async function resolveContent(inlineContent, filePath) {
   }
   if (filePath) {
     try {
-      return { ok: true, content: await readFile29(filePath, "utf-8") };
+      return { ok: true, content: await readFile30(filePath, "utf-8") };
     } catch (err3) {
       const msg = err3 instanceof Error ? err3.message : String(err3);
       return { ok: false, error: `Failed to read file: ${msg}` };
@@ -49440,7 +49971,7 @@ function textResult3(text, isError) {
 }
 async function handlePresentInline(filePath, vizType) {
   try {
-    const content = await readFile29(filePath, "utf-8");
+    const content = await readFile30(filePath, "utf-8");
     return {
       content: [
         { type: "text", text: content },
@@ -49480,7 +50011,7 @@ async function refreshCanvasPresentationFromFile(vizWatcher, slug) {
   if (!viz) return { ok: false, title: slug, reason: "no_canvas_element" };
   if (!viz.canvasElementId) return { ok: false, title: viz.title, reason: "no_canvas_element" };
   try {
-    const content = await readFile29(viz.filePath, "utf-8");
+    const content = await readFile30(viz.filePath, "utf-8");
     const effects = vizWatcher.registry.refreshCanvasPresentation(slug, content);
     await vizWatcher.executeEffects(effects);
     return { ok: true, title: viz.title };
@@ -49567,7 +50098,7 @@ Fix the content and try again.`
     await ctx.vizWatcher.executeEffects([
       { type: "write_file", filePath: existingFilePath, content }
     ]);
-    const persisted = await readFile29(existingFilePath, "utf-8").catch((err3) => {
+    const persisted = await readFile30(existingFilePath, "utf-8").catch((err3) => {
       ctx.log({
         event: "viz_update_reconcile_read_failed",
         filePath: existingFilePath,
@@ -50085,7 +50616,7 @@ import { pathToFileURL as pathToFileURL3 } from "url";
 // src/services/lsp/language-server-registry.ts
 import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import { dirname as dirname21, isAbsolute as isAbsolute4, join as join52 } from "path";
+import { dirname as dirname22, isAbsolute as isAbsolute4, join as join53 } from "path";
 function decideTypescriptServer(d) {
   if (d.hasAngular || d.hasNest || d.hasTsserverPlugins) return "vtsls";
   return "tsgo";
@@ -50175,11 +50706,11 @@ function isRecord7(value) {
   return typeof value === "object" && value !== null;
 }
 function gatherTsDetection(cwd, deps) {
-  const pkg = deps.readJsonFile(join52(cwd, "package.json"));
+  const pkg = deps.readJsonFile(join53(cwd, "package.json"));
   const depNames = isRecord7(pkg) ? [...keysOf(pkg.dependencies), ...keysOf(pkg.devDependencies)] : [];
-  const hasAngular = depNames.includes("@angular/core") || deps.fileExists(join52(cwd, "angular.json"));
-  const hasNest = depNames.includes("@nestjs/core") || deps.fileExists(join52(cwd, "nest-cli.json"));
-  const tsconfig = deps.readJsonFile(join52(cwd, "tsconfig.json"));
+  const hasAngular = depNames.includes("@angular/core") || deps.fileExists(join53(cwd, "angular.json"));
+  const hasNest = depNames.includes("@nestjs/core") || deps.fileExists(join53(cwd, "nest-cli.json"));
+  const tsconfig = deps.readJsonFile(join53(cwd, "tsconfig.json"));
   const compilerOptions = isRecord7(tsconfig) ? tsconfig.compilerOptions : void 0;
   const plugins2 = isRecord7(compilerOptions) ? compilerOptions.plugins : void 0;
   const hasTsserverPlugins = Array.isArray(plugins2) && plugins2.length > 0;
@@ -50194,11 +50725,11 @@ function detectPythonVenv(cwd, deps) {
   if (envVenv && isAbsolute4(envVenv) && deps.fileExists(envVenv)) {
     candidates.push(envVenv);
   }
-  candidates.push(join52(cwd, ".venv"), join52(cwd, "venv"));
+  candidates.push(join53(cwd, ".venv"), join53(cwd, "venv"));
   const isWin = deps.platform === "win32";
   for (const root of candidates) {
-    const python = isWin ? join52(root, "Scripts", "python.exe") : join52(root, "bin", "python");
-    const python3 = isWin ? python : join52(root, "bin", "python3");
+    const python = isWin ? join53(root, "Scripts", "python.exe") : join53(root, "bin", "python");
+    const python3 = isWin ? python : join53(root, "bin", "python3");
     if (deps.fileExists(python) || deps.fileExists(python3)) return root;
   }
   return null;
@@ -50231,8 +50762,8 @@ function resolveTsgoBinaryPath(req) {
       `Unable to resolve ${platformPkg}: ${err3 instanceof Error ? err3.message : String(err3)}`
     );
   }
-  const exeDir = join52(dirname21(pkgJsonPath), "lib");
-  const exe = process.platform === "win32" ? join52(exeDir, "tsgo.exe") : join52(exeDir, "tsgo");
+  const exeDir = join53(dirname22(pkgJsonPath), "lib");
+  const exe = process.platform === "win32" ? join53(exeDir, "tsgo.exe") : join53(exeDir, "tsgo");
   if (!existsSync7(exe)) {
     throw new Error(`tsgo native binary not found: ${exe}`);
   }
@@ -50245,7 +50776,7 @@ function resolveBinViaPackageJson(pkg, binName, req) {
   const named = isRecord7(binField) ? binField[binName] : void 0;
   const bin = typeof binField === "string" ? binField : typeof named === "string" ? named : void 0;
   if (!bin) throw new Error(`package '${pkg}' has no bin entry '${binName}'`);
-  return join52(dirname21(pkgJsonPath), bin);
+  return join53(dirname22(pkgJsonPath), bin);
 }
 function errorMessage3(err3) {
   return err3 instanceof Error ? err3.message : String(err3);
@@ -51400,6 +51931,7 @@ function assertNever6(x2, context) {
 
 // src/services/mcp/server-fsm.ts
 var CONNECT_TIMEOUT_MS = 3e4;
+var COLD_CONNECT_TIMEOUT_MS = 12e4;
 function snapshotToStatusEntry(snap) {
   const entry = {
     name: snap.name,
@@ -51427,7 +51959,22 @@ function initialSnapshot(name, startEnabled) {
     config: null,
     toolCount: 0,
     serverInfo: null,
-    error: null
+    error: null,
+    connectAttemptCount: startEnabled ? 1 : 0
+  };
+}
+function connectTimeoutMsForAttempt(attemptCount) {
+  return attemptCount <= 1 ? COLD_CONNECT_TIMEOUT_MS : CONNECT_TIMEOUT_MS;
+}
+function formatConnectTimeoutError(ms) {
+  return `Connect timeout (${Math.round(ms / 1e3)}s)`;
+}
+function enterConnecting(snap) {
+  return {
+    ...snap,
+    state: "connecting",
+    error: null,
+    connectAttemptCount: snap.connectAttemptCount + 1
   };
 }
 function illegal(state, eventType) {
@@ -51452,17 +51999,16 @@ function transition3(snap, event) {
 function fromDisabled(snap, event) {
   switch (event.type) {
     case "enable": {
-      const next = {
-        ...snap,
-        state: "connecting",
-        config: event.config,
-        error: null
-      };
+      const next = { ...enterConnecting(snap), config: event.config };
       return {
         snapshot: next,
         effects: [
           { type: "OpenTransport", name: snap.name, config: event.config },
-          { type: "StartConnectTimer", name: snap.name, ms: CONNECT_TIMEOUT_MS },
+          {
+            type: "StartConnectTimer",
+            name: snap.name,
+            ms: connectTimeoutMsForAttempt(next.connectAttemptCount)
+          },
           { type: "BroadcastStatus", entry: snapshotToStatusEntry(next) }
         ]
       };
@@ -51555,7 +52101,7 @@ function fromConnecting(snap, event) {
       const next = {
         ...snap,
         state: "failed",
-        error: "Connect timeout (30s)"
+        error: formatConnectTimeoutError(event.ms)
       };
       return {
         snapshot: next,
@@ -51667,16 +52213,16 @@ function fromNeedsAuth(snap, event) {
       if (snap.config === null) {
         throw new Error(`MCP FSM: reauth_completed for "${snap.name}" without retained config`);
       }
-      const next = {
-        ...snap,
-        state: "connecting",
-        error: null
-      };
+      const next = enterConnecting(snap);
       return {
         snapshot: next,
         effects: [
           { type: "OpenTransport", name: snap.name, config: snap.config },
-          { type: "StartConnectTimer", name: snap.name, ms: CONNECT_TIMEOUT_MS },
+          {
+            type: "StartConnectTimer",
+            name: snap.name,
+            ms: connectTimeoutMsForAttempt(next.connectAttemptCount)
+          },
           { type: "EmitReauthCompleted", name: snap.name },
           { type: "BroadcastStatus", entry: snapshotToStatusEntry(next) }
         ]
@@ -51715,17 +52261,16 @@ function fromFailed(snap, event) {
       };
     }
     case "enable": {
-      const next = {
-        ...snap,
-        state: "connecting",
-        config: event.config,
-        error: null
-      };
+      const next = { ...enterConnecting(snap), config: event.config };
       return {
         snapshot: next,
         effects: [
           { type: "OpenTransport", name: snap.name, config: event.config },
-          { type: "StartConnectTimer", name: snap.name, ms: CONNECT_TIMEOUT_MS },
+          {
+            type: "StartConnectTimer",
+            name: snap.name,
+            ms: connectTimeoutMsForAttempt(next.connectAttemptCount)
+          },
           { type: "BroadcastStatus", entry: snapshotToStatusEntry(next) }
         ]
       };
@@ -52118,7 +52663,7 @@ var ConnectTimer = class {
     const set = this.#deps.setTimeoutFn ?? setTimeout;
     const handle = set(() => {
       this.#handles.delete(name);
-      this.#deps.onTimeout(name);
+      this.#deps.onTimeout(name, ms);
     }, ms);
     if (hasUnref(handle)) handle.unref();
     this.#handles.set(name, handle);
@@ -52182,7 +52727,6 @@ var BOOTSTRAP_OPEN_JITTER_BASE_MS = 100;
 var BOOTSTRAP_OPEN_JITTER_MS = 500;
 var OPEN_TRANSPORT_BURST_WINDOW_MS = 200;
 var STDIO_NO_AGENT_SENTINEL_MS = 5 * 6e4;
-var CONNECT_TIMEOUT_MS2 = 3e4;
 var McpCoordinator = class {
   #deps;
   #registry;
@@ -52225,8 +52769,8 @@ var McpCoordinator = class {
     } : void 0;
     this.#dedup = new TerminalReconnectDedup(deps.log, gatedSendUserActionRequired);
     this.#timer = new ConnectTimer({
-      onTimeout: (name) => {
-        this.#registry.dispatch(name, { type: "timeout" });
+      onTimeout: (name, ms) => {
+        this.#registry.dispatch(name, { type: "timeout", ms });
       },
       ...deps.setTimeoutFn ? { setTimeoutFn: deps.setTimeoutFn } : {},
       ...deps.clearTimeoutFn ? { clearTimeoutFn: deps.clearTimeoutFn } : {}
@@ -52765,7 +53309,7 @@ var McpCoordinator = class {
     }
     for (const snap of this.#snapshots()) {
       if (snap.state === "connecting" && snap.config?.transport === "stdio") {
-        this.#timer.start(snap.name, CONNECT_TIMEOUT_MS2);
+        this.#timer.start(snap.name, CONNECT_TIMEOUT_MS);
       }
     }
     for (const snap of this.#snapshots()) {
@@ -53109,9 +53653,9 @@ import { auth } from "@modelcontextprotocol/sdk/client/auth.js";
 // src/shared/mcp/codex-credentials.ts
 import { execFile as execFileCb3 } from "child_process";
 import { createHash as createHash3 } from "crypto";
-import { readFile as readFile30 } from "fs/promises";
+import { readFile as readFile31 } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { join as join53 } from "path";
+import { join as join54 } from "path";
 import { promisify as promisify9 } from "util";
 var execFile10 = promisify9(execFileCb3);
 var CodexCredentialsEntrySchema = external_exports.object({
@@ -53172,10 +53716,10 @@ async function readKeychainStore() {
     return null;
   }
 }
-async function readCodexMcpCredentials(serverName, serverUrl, codexHome = join53(homedir7(), ".codex")) {
+async function readCodexMcpCredentials(serverName, serverUrl, codexHome = join54(homedir7(), ".codex")) {
   if (!serverUrl) return null;
   try {
-    const raw = await readFile30(join53(codexHome, FALLBACK_FILENAME), "utf-8");
+    const raw = await readFile31(join54(codexHome, FALLBACK_FILENAME), "utf-8");
     const fileResult = CodexCredentialsFileSchema.safeParse(JSON.parse(raw));
     if (fileResult.success) {
       const entry = findEntry2(fileResult.data, serverName, serverUrl);
@@ -55676,9 +56220,9 @@ function startPlanDocPersistenceGapReporter(deps) {
 }
 
 // src/services/metrics/stall-profiler.ts
-import { mkdir as mkdir19, readdir as readdir18, unlink as unlink13, writeFile as writeFile20 } from "fs/promises";
+import { mkdir as mkdir20, readdir as readdir18, unlink as unlink13, writeFile as writeFile20 } from "fs/promises";
 import { Session as Session2 } from "inspector/promises";
-import { join as join54 } from "path";
+import { join as join55 } from "path";
 import { monitorEventLoopDelay as monitorEventLoopDelay3 } from "perf_hooks";
 function hasProfile2(value) {
   return typeof value === "object" && value !== null && "profile" in value;
@@ -55788,8 +56332,8 @@ var StallProfiler = class {
       const isoTs = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
       const stallRounded = Math.round(stallMs);
       const filename = `stall-${isoTs}-${stallRounded}ms.cpuprofile`;
-      const profilePath = join54(this.#outDir, filename);
-      await mkdir19(this.#outDir, { recursive: true });
+      const profilePath = join55(this.#outDir, filename);
+      await mkdir20(this.#outDir, { recursive: true });
       await writeFile20(profilePath, JSON.stringify(stopResult.profile));
       this.#log({
         event: "stall_profile_captured",
@@ -55822,7 +56366,7 @@ var StallProfiler = class {
       const entries = await readdir18(this.#outDir);
       const toDelete = planProfileEviction(entries, this.#maxProfiles, STALL_PROFILE_PREFIX);
       if (toDelete.length === 0) return;
-      const results = await Promise.allSettled(toDelete.map((f2) => unlink13(join54(this.#outDir, f2))));
+      const results = await Promise.allSettled(toDelete.map((f2) => unlink13(join55(this.#outDir, f2))));
       const failures = results.filter((r) => r.status === "rejected").length;
       if (failures > 0) {
         this.#log({
@@ -66359,12 +66903,12 @@ function handleTaskStoreBroadcast(deps, event) {
 }
 
 // src/services/serve-factory/viz-preview.ts
-import { join as join57 } from "path";
+import { join as join58 } from "path";
 
 // src/services/harness/visualization-file-watcher.ts
 import { randomUUID as randomUUID16 } from "crypto";
-import { mkdir as mkdir20, readFile as readFile31, rename as rename16, writeFile as writeFile21 } from "fs/promises";
-import { basename as basename10, dirname as dirname22, join as join55 } from "path";
+import { mkdir as mkdir21, readFile as readFile32, rename as rename16, writeFile as writeFile21 } from "fs/promises";
+import { basename as basename10, dirname as dirname23, join as join56 } from "path";
 var PREVIEW_DEFAULT_W = 1200;
 var PREVIEW_DEFAULT_H = 800;
 function previewDataToLoroValue(data) {
@@ -66417,7 +66961,7 @@ function mergedPreviewData(data, state) {
 }
 var DEBOUNCE_MS3 = 200;
 async function atomicWrite2(filePath, content) {
-  await mkdir20(dirname22(filePath), { recursive: true });
+  await mkdir21(dirname23(filePath), { recursive: true });
   const tmpPath = `${filePath}.${randomUUID16()}.tmp`;
   await writeFile21(tmpPath, content, "utf-8");
   await rename16(tmpPath, filePath);
@@ -66513,7 +67057,7 @@ var VisualizationFileWatcher = class {
     const byTask = /* @__PURE__ */ new Map();
     for (const viz of allViz) {
       try {
-        const content = await readFile31(viz.filePath, "utf-8");
+        const content = await readFile32(viz.filePath, "utf-8");
         let items = byTask.get(viz.taskId);
         if (!items) {
           items = [];
@@ -66576,7 +67120,7 @@ var VisualizationFileWatcher = class {
       }
       case "persist_registry":
         await atomicWrite2(
-          join55(this.#deps.vizDir, effect.taskId, "registry.json"),
+          join56(this.#deps.vizDir, effect.taskId, "registry.json"),
           JSON.stringify(effect.data, null, 2)
         );
         break;
@@ -66588,7 +67132,7 @@ var VisualizationFileWatcher = class {
     if (this.#disposed) return;
     if (this.#watchedFiles.has(filePath)) return;
     this.#watchedFiles.add(filePath);
-    const dirPath = dirname22(filePath);
+    const dirPath = dirname23(filePath);
     const existing = this.#dirWatchers.get(dirPath);
     if (existing) {
       existing.refCount += 1;
@@ -66602,7 +67146,7 @@ var VisualizationFileWatcher = class {
     const findWatchedFile = (eventPath) => {
       const eventBase = basename10(eventPath);
       for (const wf of this.#watchedFiles) {
-        if (dirname22(wf) === dirPath && basename10(wf) === eventBase) return wf;
+        if (dirname23(wf) === dirPath && basename10(wf) === eventBase) return wf;
       }
       return null;
     };
@@ -66655,7 +67199,7 @@ var VisualizationFileWatcher = class {
   }
   #stopFileWatch(filePath) {
     if (!this.#watchedFiles.delete(filePath)) return;
-    const dirPath = dirname22(filePath);
+    const dirPath = dirname23(filePath);
     const entry = this.#dirWatchers.get(dirPath);
     if (entry) {
       entry.refCount -= 1;
@@ -66777,7 +67321,7 @@ var VisualizationFileWatcher = class {
     let content = effect.content;
     if (!content && effect.filePath) {
       try {
-        content = await readFile31(effect.filePath, "utf-8");
+        content = await readFile32(effect.filePath, "utf-8");
       } catch {
         content = "";
       }
@@ -66823,7 +67367,7 @@ var VisualizationFileWatcher = class {
   async #handleFileChange(filePath) {
     let content;
     try {
-      content = await readFile31(filePath, "utf-8");
+      content = await readFile32(filePath, "utf-8");
     } catch {
       return;
     }
@@ -66874,7 +67418,7 @@ var VisualizationFileWatcher = class {
 
 // src/services/harness/visualization-registry.ts
 import { createHash as createHash5 } from "crypto";
-import { join as join56 } from "path";
+import { join as join57 } from "path";
 function hashContent(content) {
   return createHash5("sha256").update(content).digest("hex");
 }
@@ -66888,7 +67432,7 @@ var VisualizationRegistry = class {
       return null;
     }
     const ext = vizFileExtension(vizType);
-    const filePath = join56(vizDir, taskId, `${slug}${ext}`);
+    const filePath = join57(vizDir, taskId, `${slug}${ext}`);
     const contentHash3 = hashContent(content);
     const viz = {
       slug,
@@ -67039,7 +67583,7 @@ var VisualizationRegistry = class {
 // src/services/serve-factory/viz-preview.ts
 function createVizPreviewRegistry(deps) {
   const { canvasRepo } = deps;
-  const vizDir = join57(deps.dataDir, "visualizations");
+  const vizDir = join58(deps.dataDir, "visualizations");
   const vizWatchers = /* @__PURE__ */ new Map();
   function getOrCreateVizWatcher(taskId) {
     const existing = vizWatchers.get(taskId);
@@ -67138,7 +67682,7 @@ function createVizPreviewRegistry(deps) {
 import { createHmac, timingSafeEqual as timingSafeEqual3 } from "crypto";
 import { promises as fs } from "fs";
 import { createServer as createServer5 } from "net";
-import { dirname as dirname23 } from "path";
+import { dirname as dirname24 } from "path";
 var NONCE_TTL_MS = 12e4;
 var NONCE_CACHE_MAX = 1e5;
 var CursorHookSocketServer = class {
@@ -67162,7 +67706,7 @@ var CursorHookSocketServer = class {
     if (this.#hmacSecret.length === 0) {
       throw new Error(`cursor-hook-socket: empty HMAC keyfile at ${this.#opts.hmacKeyfile}`);
     }
-    await fs.mkdir(dirname23(this.#opts.socketPath), { recursive: true, mode: 448 });
+    await fs.mkdir(dirname24(this.#opts.socketPath), { recursive: true, mode: 448 });
     await fs.rm(this.#opts.socketPath, { force: true });
     const server = createServer5((conn) => {
       this.#handleConnection(conn);
@@ -70347,7 +70891,7 @@ function createCursorVaultKeyCache() {
 }
 
 // src/services/session/skills/cursor-skill-body-resolver.ts
-import { readFile as readFile32 } from "fs/promises";
+import { readFile as readFile33 } from "fs/promises";
 function skillKey(name, namespace) {
   return namespace ? `${namespace}:${name}` : name;
 }
@@ -70400,7 +70944,7 @@ function collectInvocations(blocks) {
   return out;
 }
 async function readUtf8(path5) {
-  return readFile32(path5, "utf-8");
+  return readFile33(path5, "utf-8");
 }
 async function resolveCursorSkillBodiesFromTrustedSkills(blocks, skills, log, readSkillFile = readUtf8) {
   const invocations = collectInvocations(blocks);
@@ -70513,7 +71057,7 @@ function buildCreationSkillDefaults(entries) {
 
 // src/services/skills/skill-resolution-service.ts
 import { mkdir as mkdir23, readdir as readdir19, readFile as readFile34, writeFile as writeFile23 } from "fs/promises";
-import { basename as basename11, dirname as dirname26, join as join61, relative as relative8, resolve as resolve11, sep as sep6 } from "path";
+import { basename as basename11, dirname as dirname26, join as join62, relative as relative8, resolve as resolve11, sep as sep6 } from "path";
 
 // src/services/skills/bundle-schema.ts
 var SKILL_BUNDLE_VERSION = 2;
@@ -70641,196 +71185,10 @@ function migrateSkillBundle(raw) {
 
 // src/services/skills/bundle-store.ts
 import { createHash as createHash9 } from "crypto";
-import { join as join59 } from "path";
-
-// src/services/storage/json-document-store.ts
-import { mkdir as mkdir21, readFile as readFile33 } from "fs/promises";
-import { dirname as dirname24 } from "path";
-var WRITE_DEBOUNCE_MS = 50;
-function applyMutations(records, mutations) {
-  for (const [id, mutation] of mutations) {
-    if (mutation.kind === "delete") {
-      delete records[id];
-    } else {
-      records[id] = mutation.data;
-    }
-  }
-}
-function resolveWaiters(waiters) {
-  for (const waiter of waiters) waiter.resolve();
-}
-function rejectWaiters(waiters, error) {
-  for (const waiter of waiters) waiter.reject(error);
-}
-function buildJsonDocumentStore(opts) {
-  const { filePath, recordSchema, currentVersion, migrate, storeName, docType } = opts;
-  let cache2 = null;
-  const listeners = /* @__PURE__ */ new Set();
-  let writeQueue = Promise.resolve();
-  const lockPath2 = `${filePath}.lock`;
-  let pendingMutations = /* @__PURE__ */ new Map();
-  let pendingFlushTimer = null;
-  let pendingFlushWaiters = [];
-  function notify(event) {
-    for (const listener of listeners) {
-      try {
-        listener(event);
-      } catch {
-      }
-    }
-  }
-  async function ensureDir() {
-    await mkdir21(dirname24(filePath), { recursive: true });
-  }
-  async function readFromDisk() {
-    try {
-      const raw = await readFile33(filePath, "utf-8");
-      return migrate(JSON.parse(raw));
-    } catch (err3) {
-      if (isEnoent(err3)) {
-        return { schemaVersion: currentVersion, records: {} };
-      }
-      if (isCorruptionError(err3)) {
-        const event = await quarantineCorruptFile({
-          path: filePath,
-          storeName,
-          docType,
-          error: err3,
-          defaultsApplied: true,
-          logger: opts.logger
-        });
-        opts.onCorrupt?.(event);
-        return { schemaVersion: currentVersion, records: {} };
-      }
-      throw err3;
-    }
-  }
-  async function readStore() {
-    if (cache2) return cache2;
-    cache2 = await readFromDisk();
-    return cache2;
-  }
-  async function flushPendingWrite() {
-    pendingFlushTimer = null;
-    const waiters = pendingFlushWaiters;
-    pendingFlushWaiters = [];
-    const mutations = pendingMutations;
-    pendingMutations = /* @__PURE__ */ new Map();
-    if (mutations.size === 0) {
-      resolveWaiters(waiters);
-      return;
-    }
-    try {
-      await commitMutations(mutations);
-      resolveWaiters(waiters);
-    } catch (err3) {
-      requeueMutations(mutations);
-      if (pendingMutations.size > 0 && pendingFlushTimer === null) {
-        pendingFlushTimer = setTimeout(() => {
-          void flushPendingWrite();
-        }, WRITE_DEBOUNCE_MS);
-      }
-      rejectWaiters(waiters, err3);
-    }
-  }
-  async function commitMutations(mutations) {
-    await withFileLock(lockPath2, async () => {
-      const disk = await readFromDisk();
-      applyMutations(disk.records, mutations);
-      await ensureDir();
-      await atomicWriteFile(filePath, JSON.stringify(disk));
-      applyMutations(disk.records, pendingMutations);
-      cache2 = disk;
-    });
-  }
-  function requeueMutations(mutations) {
-    for (const [id, mutation] of mutations) {
-      if (!pendingMutations.has(id)) pendingMutations.set(id, mutation);
-    }
-  }
-  function scheduleFlush() {
-    return new Promise((resolve12, reject) => {
-      pendingFlushWaiters.push({ resolve: resolve12, reject });
-      if (pendingFlushTimer) return;
-      pendingFlushTimer = setTimeout(() => {
-        void flushPendingWrite();
-      }, WRITE_DEBOUNCE_MS);
-    });
-  }
-  function enqueueWrite(op) {
-    let resultFlush;
-    const next = writeQueue.then(
-      async () => {
-        const out = await op();
-        resultFlush = out?.flush;
-      },
-      async () => {
-        const out = await op();
-        resultFlush = out?.flush;
-      }
-    );
-    writeQueue = next;
-    return next.then(() => resultFlush);
-  }
-  return {
-    async get(id) {
-      const store = await readStore();
-      const record = store.records[id];
-      return record ?? null;
-    },
-    async set(id, data) {
-      await enqueueWrite(async () => {
-        const store = await readStore();
-        store.records[id] = data;
-        pendingMutations.set(id, { kind: "set", data });
-        const flush = scheduleFlush();
-        notify({ kind: "set", id, data });
-        return { flush };
-      });
-    },
-    async update(id, fn) {
-      await enqueueWrite(async () => {
-        const store = await readStore();
-        const existing = store.records[id];
-        if (!existing) return void 0;
-        const parsed = recordSchema.parse(existing);
-        const updated = fn(parsed);
-        if (updated === parsed) return void 0;
-        store.records[id] = updated;
-        pendingMutations.set(id, { kind: "set", data: updated });
-        const flush = scheduleFlush();
-        notify({ kind: "set", id, data: updated });
-        return { flush };
-      });
-    },
-    async delete(id) {
-      await enqueueWrite(async () => {
-        const store = await readStore();
-        if (!(id in store.records)) return void 0;
-        delete store.records[id];
-        pendingMutations.set(id, { kind: "delete" });
-        const flush = scheduleFlush();
-        notify({ kind: "delete", id });
-        return { flush };
-      });
-    },
-    async list() {
-      const store = await readStore();
-      return { ...store.records };
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    }
-  };
-}
-
-// src/services/skills/bundle-store.ts
+import { join as join60 } from "path";
 var BUNDLE_RECORD_KEY = "bundle";
 function defaultSkillBundleDir(shipyardHome) {
-  return join59(shipyardHome, "state", "skill-bundles");
+  return join60(shipyardHome, "state", "skill-bundles");
 }
 function skillBundleSlug(ownerRepo) {
   return ownerRepo.replace(/[^A-Za-z0-9._-]/g, (ch) => {
@@ -70852,7 +71210,7 @@ function buildProjectSkillBundleStore(baseDir) {
     const store = buildJsonDocumentStore({
       storeName: `skill-bundle:${slug}`,
       docType: "generic",
-      filePath: join59(baseDir, `${slug}.json`),
+      filePath: join60(baseDir, `${slug}.json`),
       recordSchema: SkillBundleRecordSchema,
       currentVersion: SKILL_BUNDLE_VERSION,
       migrate: migrateSkillBundle
@@ -71244,9 +71602,9 @@ function nativeSkillIdentifier(skill) {
 // src/services/skills/skill-library-cache.ts
 import { createHash as createHash11 } from "crypto";
 import { mkdir as mkdir22, writeFile as writeFile22 } from "fs/promises";
-import { join as join60 } from "path";
+import { join as join61 } from "path";
 function defaultSkillLibraryCacheDir(shipyardHome) {
-  return join60(shipyardHome, "cache", "library-skills");
+  return join61(shipyardHome, "cache", "library-skills");
 }
 function skillCacheSlug(name, contentHash3) {
   const safeName = name.replace(/[^A-Za-z0-9._-]/g, "-");
@@ -71254,9 +71612,9 @@ function skillCacheSlug(name, contentHash3) {
   return `${safeName}-${hash}`;
 }
 async function materializeLibrarySkill(input) {
-  const dir = join60(input.baseDir, skillCacheSlug(input.name, input.contentHash));
+  const dir = join61(input.baseDir, skillCacheSlug(input.name, input.contentHash));
   await mkdir22(dir, { recursive: true });
-  const skillMdPath = join60(dir, "SKILL.md");
+  const skillMdPath = join61(dir, "SKILL.md");
   await writeFile22(skillMdPath, input.body, "utf-8");
   return { skillMdPath, dir };
 }
@@ -71515,7 +71873,7 @@ function buildSkillResolutionService(deps) {
     for (const file of files) {
       const fileSlug = basename11(file, ".json");
       if (!file.endsWith(".json") || fileSlug === currentSlug) continue;
-      const bundle = await readBundleFile(join61(dir, file));
+      const bundle = await readBundleFile(join62(dir, file));
       if (bundle !== null) bundlesBySlug.set(fileSlug, bundle);
     }
     return bundlesBySlug;
@@ -71879,14 +72237,14 @@ function buildSkillResolutionService(deps) {
     if (body === null || body.length === 0) {
       return { ok: false, error: `No body supplied and no library skill named "${args.name}"` };
     }
-    const skillsRoot = join61(repoRoot, ".claude", "skills");
+    const skillsRoot = join62(repoRoot, ".claude", "skills");
     const skillDir = resolve11(skillsRoot, args.name);
     const rel = relative8(skillsRoot, skillDir);
     if (rel.startsWith("..") || rel.includes(`..${sep6}`) || resolve11(skillsRoot, rel) !== skillDir) {
       return { ok: false, error: "Invalid skill path" };
     }
     await mkdir23(skillDir, { recursive: true });
-    await writeFile23(join61(skillDir, "SKILL.md"), body, "utf-8");
+    await writeFile23(join62(skillDir, "SKILL.md"), body, "utf-8");
     return { ok: true, name: args.name };
   }
   async function libraryBodyByName(cwd, name) {
@@ -71916,7 +72274,7 @@ function buildSkillResolutionService(deps) {
 
 // src/services/stack-detection.ts
 import { access as access5 } from "fs/promises";
-import { join as join62 } from "path";
+import { join as join63 } from "path";
 var STACK_TIMEOUT_MS = TIMEOUT_MS;
 async function defaultIsCommandAvailable(command) {
   try {
@@ -71958,7 +72316,7 @@ async function detectStack(cwd, currentBranch, deps = {}) {
 async function detectGraphite(cwd, currentBranch, isCommandAvailable, fileExists2, exec, getDefaultBranch2) {
   const gtAvailable = await isCommandAvailable("gt");
   if (!gtAvailable) return null;
-  const markerPresent = await fileExists2(join62(cwd, ".git", ".graphite_repo_config"));
+  const markerPresent = await fileExists2(join63(cwd, ".git", ".graphite_repo_config"));
   if (!markerPresent) return null;
   const ancestor = await exec("gt", ["parent"], cwd).then((s2) => normalizeBranchName(s2)).catch(() => null);
   const childrenRaw = await exec("gt", ["children"], cwd).then((s2) => s2).catch(() => "");
@@ -71971,7 +72329,7 @@ async function detectGraphite(cwd, currentBranch, isCommandAvailable, fileExists
   return { ancestor: resolvedAncestor, descendants };
 }
 async function detectJujutsu(cwd, fileExists2, exec) {
-  const jjPresent = await fileExists2(join62(cwd, ".jj"));
+  const jjPresent = await fileExists2(join63(cwd, ".jj"));
   if (!jjPresent) return null;
   const ancestorRaw = await exec(
     "jj",
@@ -72020,7 +72378,7 @@ function parseJjLines(raw) {
 
 // src/services/storage/annotation-store.ts
 import { mkdir as mkdir24, readFile as readFile35 } from "fs/promises";
-import { dirname as dirname27, join as join63 } from "path";
+import { dirname as dirname27, join as join64 } from "path";
 var LegacyBaseFields = external_exports.object({
   commentId: external_exports.string(),
   body: external_exports.string(),
@@ -72047,7 +72405,7 @@ var LegacyPlanStoreSchema = external_exports.object({
   versions: external_exports.array(PlanVersionZodSchema)
 });
 function buildAnnotationStore(dataDir) {
-  const baseDir = join63(dataDir, "annotations");
+  const baseDir = join64(dataDir, "annotations");
   const cache2 = /* @__PURE__ */ new Map();
   const listeners = /* @__PURE__ */ new Set();
   const writeQueues = /* @__PURE__ */ new Map();
@@ -72060,7 +72418,7 @@ function buildAnnotationStore(dataDir) {
     }
   }
   function filePath(taskId) {
-    return join63(baseDir, `${taskId}.json`);
+    return join64(baseDir, `${taskId}.json`);
   }
   function emptyData() {
     return {
@@ -72125,9 +72483,9 @@ function buildAnnotationStore(dataDir) {
   }
   async function migrateLegacyFiles(taskId) {
     const [diffRaw, previewRaw, planRaw] = await Promise.all([
-      readLegacyFile(join63(dataDir, "diff-review", `${taskId}.json`)),
-      readLegacyFile(join63(dataDir, "preview-annotations", `${taskId}.json`)),
-      readLegacyFile(join63(dataDir, "plan-comments", `${taskId}.json`))
+      readLegacyFile(join64(dataDir, "diff-review", `${taskId}.json`)),
+      readLegacyFile(join64(dataDir, "preview-annotations", `${taskId}.json`)),
+      readLegacyFile(join64(dataDir, "plan-comments", `${taskId}.json`))
     ]);
     if (diffRaw === null && previewRaw === null && planRaw === null) {
       return null;
@@ -72333,7 +72691,7 @@ function buildAnnotationStore(dataDir) {
 
 // src/services/storage/asset-store.ts
 import { mkdir as mkdir25, readFile as readFile36, rename as rename17, writeFile as writeFile24 } from "fs/promises";
-import { join as join64 } from "path";
+import { join as join65 } from "path";
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function isValidAssetId(id) {
   return UUID_RE.test(id);
@@ -72359,10 +72717,10 @@ function buildAssetStore(assetsDir) {
     }
   }
   function binaryPath(assetId) {
-    return join64(assetsDir, `${assetId}.bin`);
+    return join65(assetsDir, `${assetId}.bin`);
   }
   function metaPath(assetId) {
-    return join64(assetsDir, `${assetId}.meta.json`);
+    return join65(assetsDir, `${assetId}.meta.json`);
   }
   function parseMeta(raw) {
     return AssetMetadataSchema.parse(JSON.parse(raw));
@@ -72386,8 +72744,8 @@ function buildAssetStore(assetsDir) {
         size: data.byteLength,
         createdAt: Date.now()
       };
-      const tmpBin = join64(assetsDir, `${assetId}.bin.tmp`);
-      const tmpMeta = join64(assetsDir, `${assetId}.meta.tmp`);
+      const tmpBin = join65(assetsDir, `${assetId}.bin.tmp`);
+      const tmpMeta = join65(assetsDir, `${assetId}.meta.tmp`);
       await writeFile24(tmpBin, data);
       await writeFile24(tmpMeta, JSON.stringify(metadata), "utf-8");
       await rename17(tmpBin, binaryPath(assetId));
@@ -72612,7 +72970,7 @@ function buildCredentialsVaultStore(filePath, corruptionLogger) {
 
 // src/services/storage/deliverable-store.ts
 import { mkdir as mkdir27, readFile as readFile38 } from "fs/promises";
-import { dirname as dirname29, join as join65 } from "path";
+import { dirname as dirname29, join as join66 } from "path";
 var DELIVERABLE_STORE_VERSION = 1;
 var DeliverableStoreSchema = external_exports.object({
   schemaVersion: external_exports.number(),
@@ -72626,7 +72984,7 @@ function migrateDeliverableStore(raw) {
   return { schemaVersion: DELIVERABLE_STORE_VERSION, records: [] };
 }
 function buildDeliverableStore(dataDir) {
-  const baseDir = join65(dataDir, "deliverables");
+  const baseDir = join66(dataDir, "deliverables");
   const cache2 = /* @__PURE__ */ new Map();
   const listeners = /* @__PURE__ */ new Set();
   const writeQueues = /* @__PURE__ */ new Map();
@@ -72639,7 +72997,7 @@ function buildDeliverableStore(dataDir) {
     }
   }
   function filePath(taskId) {
-    return join65(baseDir, `${taskId}.json`);
+    return join66(baseDir, `${taskId}.json`);
   }
   function emptyData() {
     return { schemaVersion: DELIVERABLE_STORE_VERSION, records: [] };
@@ -72779,7 +73137,7 @@ function buildDeliverableStore(dataDir) {
 
 // src/services/storage/jsonl-conversation-store.ts
 import { appendFile as appendFile3, mkdir as mkdir28, open, readFile as readFile39, stat as stat17 } from "fs/promises";
-import { join as join66 } from "path";
+import { join as join67 } from "path";
 var StoredMessageSchema = MessageSchema.omit({ seqNo: true, channelId: true });
 function logPerf(entry) {
   try {
@@ -72789,12 +73147,12 @@ function logPerf(entry) {
   }
 }
 function buildJsonlConversationStore(dataDir, opts = {}) {
-  const channelsDir = join66(dataDir, "channels");
+  const channelsDir = join67(dataDir, "channels");
   const seqCounters = /* @__PURE__ */ new Map();
   const channelQueues = /* @__PURE__ */ new Map();
   const readCache = /* @__PURE__ */ new Map();
   function channelPath(channelId) {
-    return join66(channelsDir, `${channelId}.jsonl`);
+    return join67(channelsDir, `${channelId}.jsonl`);
   }
   async function ensureDir() {
     await mkdir28(channelsDir, { recursive: true });
@@ -73566,7 +73924,7 @@ function buildProjectsStore(filePath) {
 
 // src/services/storage/rate-limit-store.ts
 import { mkdir as mkdir30, readFile as readFile41 } from "fs/promises";
-import { dirname as dirname31, join as join67 } from "path";
+import { dirname as dirname31, join as join68 } from "path";
 var RATE_LIMIT_STORE_VERSION = 4;
 var RateLimitRecordSchema = external_exports.object({
   info: RateLimitInfoSchema,
@@ -73605,7 +73963,7 @@ function isWindowKey(x2) {
   return x2 !== void 0 && WINDOW_KEYS.has(x2);
 }
 async function buildRateLimitStore(dataDir, opts) {
-  const filePath = join67(dataDir, "rate-limits.json");
+  const filePath = join68(dataDir, "rate-limits.json");
   const lockPath2 = `${filePath}.lock`;
   const initial = await loadStoreFile(filePath, opts.logger);
   const records = { ...initial.records };
@@ -73858,12 +74216,12 @@ async function atomicWrite4(filePath, data) {
 }
 
 // src/services/storage/schedule-store.ts
-import { join as join68 } from "path";
+import { join as join69 } from "path";
 function buildScheduleStore(dataDir) {
   const store = buildJsonDocumentStore({
     storeName: "schedules",
     docType: "schedule",
-    filePath: join68(dataDir, "schedules.json"),
+    filePath: join69(dataDir, "schedules.json"),
     recordSchema: ScheduleRecordSchema,
     currentVersion: SCHEDULE_STORE_VERSION,
     migrate(raw) {
@@ -73902,7 +74260,7 @@ function buildScheduleStore(dataDir) {
 
 // src/services/storage/session-persistence.ts
 import { mkdir as mkdir31, readdir as readdir20, readFile as readFile42, rm as rm11 } from "fs/promises";
-import { join as join69 } from "path";
+import { join as join70 } from "path";
 var PersistedSessionSchema = external_exports.object({
   sessionId: external_exports.string(),
   channelId: external_exports.string(),
@@ -73959,9 +74317,9 @@ async function loadOneSessionFile(originalPath, corruptionLogger) {
   }
 }
 function buildSessionPersistence(dataDir, corruptionLogger) {
-  const channelsDir = join69(dataDir, "channels");
+  const channelsDir = join70(dataDir, "channels");
   function sessionPath(channelId) {
-    return join69(channelsDir, `${channelId}.session.json`);
+    return join70(channelsDir, `${channelId}.session.json`);
   }
   async function ensureDir() {
     await mkdir31(channelsDir, { recursive: true });
@@ -74019,7 +74377,7 @@ function buildSessionPersistence(dataDir, corruptionLogger) {
           if (i >= sessionEntries.length) return;
           const entry = sessionEntries[i];
           if (!entry) return;
-          results[i] = await loadOneSessionFile(join69(channelsDir, entry), corruptionLogger);
+          results[i] = await loadOneSessionFile(join70(channelsDir, entry), corruptionLogger);
         }
       }
       const workers = Array.from(
@@ -74033,12 +74391,12 @@ function buildSessionPersistence(dataDir, corruptionLogger) {
 }
 
 // src/services/storage/template-store.ts
-import { join as join70 } from "path";
+import { join as join71 } from "path";
 function buildTemplateStore(dataDir) {
   const store = buildJsonDocumentStore({
     storeName: "templates",
     docType: "template",
-    filePath: join70(dataDir, "templates.json"),
+    filePath: join71(dataDir, "templates.json"),
     recordSchema: TaskTemplateRecordSchema,
     currentVersion: TEMPLATE_STORE_VERSION,
     migrate(raw) {
@@ -79770,7 +80128,7 @@ import { randomUUID as randomUUID21 } from "crypto";
 import { existsSync as existsSync10, readdirSync as readdirSync5, statSync as statSync5 } from "fs";
 import { mkdir as mkdir33, readFile as readFile45, writeFile as writeFile26 } from "fs/promises";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname34, join as join72 } from "path";
+import { dirname as dirname34, join as join73 } from "path";
 
 // src/services/plan-backfill/plan-lazy-rebuild.ts
 var SETTLE_BUDGET_MS = 2e3;
@@ -80540,8 +80898,8 @@ function greedyLCS(a, b2) {
 // src/services/plan/plan-file-watcher.ts
 import { existsSync as existsSync9 } from "fs";
 import { homedir as homedir9 } from "os";
-import { join as join71 } from "path";
-var DEFAULT_PLANS_DIR = join71(homedir9(), ".claude", "plans");
+import { join as join72 } from "path";
+var DEFAULT_PLANS_DIR = join72(homedir9(), ".claude", "plans");
 var PLAN_WATCH_TIMEOUT_MS = 1e4;
 var PLAN_WATCH_DEBOUNCE_MS = 250;
 function createPlanFileWatcher(deps) {
@@ -81079,7 +81437,7 @@ var PlanHandler = class {
    * Called when a Write tool result mentions a file in ~/.claude/plans/.
    */
   trackCreatedFile(filePath) {
-    const plansDir = join72(homedir10(), ".claude", "plans");
+    const plansDir = join73(homedir10(), ".claude", "plans");
     if (filePath.startsWith(plansDir) && filePath.endsWith(".md")) {
       this.#createdPlanFiles.add(filePath);
       this.#deps.log({
@@ -81111,7 +81469,7 @@ var PlanHandler = class {
   }
   async #runHandleCodexPlanReady(content) {
     if (this.#deps.isDisposed()) return;
-    const filePath = join72(getShipyardHome(), "plans", `${this.#deps.taskId}.md`);
+    const filePath = join73(getShipyardHome(), "plans", `${this.#deps.taskId}.md`);
     try {
       await mkdir33(dirname34(filePath), { recursive: true });
       await writeFile26(filePath, content, "utf-8");
@@ -81590,12 +81948,12 @@ var PlanHandler = class {
       }).filter((f2) => f2 !== null).sort((a, b2) => b2.mtime - a.mtime)[0];
       return newest?.path ?? null;
     }
-    const plansDir = join72(homedir10(), ".claude", "plans");
+    const plansDir = join73(homedir10(), ".claude", "plans");
     if (!existsSync10(plansDir)) return null;
     try {
       const files = readdirSync5(plansDir).filter((f2) => f2.endsWith(".md")).map((f2) => ({
-        path: join72(plansDir, f2),
-        mtime: statSync5(join72(plansDir, f2)).mtimeMs
+        path: join73(plansDir, f2),
+        mtime: statSync5(join73(plansDir, f2)).mtimeMs
       })).sort((a, b2) => b2.mtime - a.mtime);
       const recent = files[0];
       if (recent && Date.now() - recent.mtime < 3e4) return recent.path;
@@ -83822,7 +84180,7 @@ var RewindCheckpointHandler = class {
 
 // src/services/task/side-thread-registry.ts
 import { mkdir as mkdir34, readFile as readFile46, rename as rename19, writeFile as writeFile27 } from "fs/promises";
-import { dirname as dirname35, join as join73 } from "path";
+import { dirname as dirname35, join as join74 } from "path";
 var ThreadFileSchema = external_exports.object({
   threads: external_exports.record(external_exports.string(), ThreadMetadataSchema)
 });
@@ -84198,7 +84556,7 @@ var SideThreadRegistry = class {
   }
   /** Persistence */
   #filePath() {
-    return join73(this.#deps.dataDir, "threads", `${this.#deps.taskId}.json`);
+    return join74(this.#deps.dataDir, "threads", `${this.#deps.taskId}.json`);
   }
   async #ensureLoaded() {
     if (this.#loadedFromDisk.has(this.#deps.taskId)) return;
@@ -87115,7 +87473,7 @@ async function resolveTaskListPrepend(ctx) {
 import { existsSync as existsSync11 } from "fs";
 import { readdir as readdir21, readFile as readFile47 } from "fs/promises";
 import { homedir as homedir11 } from "os";
-import { basename as basename13, dirname as dirname36, join as join74 } from "path";
+import { basename as basename13, dirname as dirname36, join as join75 } from "path";
 var VALID_STATUSES = /* @__PURE__ */ new Set(["pending", "in_progress", "completed"]);
 var IDLE_DETACH_MS = 5 * 60 * 1e3;
 var IDLE_SWEEP_INTERVAL_MS = 6e4;
@@ -87131,7 +87489,7 @@ function isCCTaskFile(value) {
 }
 function createCCTaskFileWatcher(listId, log) {
   const sanitizedId = sanitize(listId);
-  const dir = join74(homedir11(), ".claude", "tasks", sanitizedId);
+  const dir = join75(homedir11(), ".claude", "tasks", sanitizedId);
   const targetDirName = basename13(dir);
   const parentDir = dirname36(dir);
   const watchState = {
@@ -87167,7 +87525,7 @@ function createCCTaskFileWatcher(listId, log) {
     return tasks;
   }
   async function readTask(taskId) {
-    const filePath = join74(dir, `${taskId}.json`);
+    const filePath = join75(dir, `${taskId}.json`);
     try {
       const raw = await readFile47(filePath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -87234,7 +87592,7 @@ function createCCTaskFileWatcher(listId, log) {
         watchState.parentSub = null;
         return;
       }
-      if (ev.path.endsWith(targetDirName) || ev.path === join74(parentDir, targetDirName)) {
+      if (ev.path.endsWith(targetDirName) || ev.path === join75(parentDir, targetDirName)) {
         void ensureDirWatcher();
         break;
       }
@@ -87351,7 +87709,7 @@ function createCCTaskFileWatcher(listId, log) {
 // src/services/task/cc-task-file-writer.ts
 import { createHash as createHash13 } from "crypto";
 import { mkdir as mkdir35, readdir as readdir22, rename as rename20, unlink as unlink14, writeFile as writeFile28 } from "fs/promises";
-import { join as join75 } from "path";
+import { join as join76 } from "path";
 function contentHash2(data) {
   return createHash13("sha256").update(data).digest("hex").slice(0, 16);
 }
@@ -87367,7 +87725,7 @@ async function writeTasks(dir, tasks, hashes) {
     const json = JSON.stringify(structuredTaskToCCFile(task), null, 2);
     const hash = contentHash2(json);
     if (hashes.get(id) === hash) continue;
-    await atomicWriteFile2(join75(dir, `${id}.json`), json);
+    await atomicWriteFile2(join76(dir, `${id}.json`), json);
     hashes.set(id, hash);
   }
   return targetIds;
@@ -87383,7 +87741,7 @@ async function removeStaleFiles(dir, targetIds, hashes) {
     if (!entry.endsWith(".json")) continue;
     const id = entry.slice(0, -".json".length);
     if (!targetIds.has(id) && hashes.has(id)) {
-      await unlink14(join75(dir, entry)).catch(() => {
+      await unlink14(join76(dir, entry)).catch(() => {
       });
       hashes.delete(id);
     }
@@ -88015,10 +88373,10 @@ var StructuredTaskTracker = class {
 import { unwatchFile, watchFile } from "fs";
 import { open as open2 } from "fs/promises";
 import { homedir as homedir12 } from "os";
-import { join as join76 } from "path";
+import { join as join77 } from "path";
 function computeTranscriptPath(cwd, sessionId, taskId) {
   const cwdSlug = cwd.replace(/[^a-zA-Z0-9]/g, "-").slice(0, 200);
-  return join76(
+  return join77(
     homedir12(),
     ".claude",
     "projects",
@@ -88733,7 +89091,7 @@ import { createHash as createHash14 } from "crypto";
 import { unlink as unlink15, writeFile as writeFile29 } from "fs/promises";
 import { createRequire as createRequire4 } from "module";
 import { tmpdir } from "os";
-import { join as join77 } from "path";
+import { join as join78 } from "path";
 function spawnCollect(bin, args, opts) {
   return new Promise((resolve12, reject) => {
     const child = spawn12(bin, args, {
@@ -88791,7 +89149,7 @@ function resolveDaemonNodeModules(log) {
   } catch {
   }
   try {
-    const cwdRequire = createRequire4(join77(process.cwd(), "package.json"));
+    const cwdRequire = createRequire4(join78(process.cwd(), "package.json"));
     const sdkPath = cwdRequire.resolve("@modelcontextprotocol/sdk/server/mcp.js");
     const idx = sdkPath.lastIndexOf("node_modules");
     if (idx >= 0) return sdkPath.slice(0, idx + "node_modules".length);
@@ -88801,7 +89159,7 @@ function resolveDaemonNodeModules(log) {
       error: err3 instanceof Error ? err3.message : String(err3)
     });
   }
-  return join77(process.cwd(), "node_modules");
+  return join78(process.cwd(), "node_modules");
 }
 function planTokenCount(systemPrompt, metadata, cwd, model, mcpServers) {
   return {
@@ -89000,7 +89358,7 @@ async function serializeMcpConfig(servers, allToolNames, daemonNodeModules, rese
     if (isReservedMcpServerName(serverName, reservedServerNames)) continue;
     const script = buildStubServerScript(serverName, tools);
     if (!script) continue;
-    const stubPath = join77(tmpdir(), `shipyard-mcp-stub-${serverName}-${Date.now()}.cjs`);
+    const stubPath = join78(tmpdir(), `shipyard-mcp-stub-${serverName}-${Date.now()}.cjs`);
     await writeFile29(stubPath, script, "utf-8");
     stubPaths.push(stubPath);
     mcpServers[serverName] = {
@@ -89026,7 +89384,7 @@ async function prepareTokenCountArgs(plan, log, reservedServerNames = SDK_RESERV
     reservedServerNames
   );
   if (!serialized.config) return { args, mcpConfigPath: null, stubPaths: serialized.stubPaths };
-  const mcpConfigPath = join77(tmpdir(), `shipyard-mcp-${Date.now()}.json`);
+  const mcpConfigPath = join78(tmpdir(), `shipyard-mcp-${Date.now()}.json`);
   await writeFile29(mcpConfigPath, JSON.stringify(serialized.config), "utf-8");
   args.push("--mcp-config", mcpConfigPath);
   return { args, mcpConfigPath, stubPaths: serialized.stubPaths };
@@ -95122,7 +95480,7 @@ async function createDaemon(deps) {
   const annotationStore = buildAnnotationStore(deps.dataDir);
   const deliverableStore = buildDeliverableStore(deps.dataDir);
   const resourceRegistry = createResourceRegistry();
-  const assetStore = buildAssetStore(join78(deps.dataDir, "assets"));
+  const assetStore = buildAssetStore(join79(deps.dataDir, "assets"));
   const shipyardResolver = createShipyardResolver();
   shipyardResolver.addSubResolver("asset", createAssetResolver(assetStore));
   const pluginResourceResolver = new PluginResourceResolver(deps.log);
@@ -95149,10 +95507,10 @@ async function createDaemon(deps) {
     workspaceRoot: deps.workspaceRoot,
     log: deps.log
   });
-  const userSettingsStore = buildUserSettingsStore(join78(deps.dataDir, "user-settings.json"));
-  const projectsStore = buildProjectsStore(join78(deps.dataDir, "projects.json"));
+  const userSettingsStore = buildUserSettingsStore(join79(deps.dataDir, "user-settings.json"));
+  const projectsStore = buildProjectsStore(join79(deps.dataDir, "projects.json"));
   const credentialsVaultStore = buildCredentialsVaultStore(
-    join78(deps.dataDir, "credentials-vault.json")
+    join79(deps.dataDir, "credentials-vault.json")
   );
   const cursorVaultKeyRef = { current: null };
   let resolveCursorVaultKey;
@@ -95600,7 +95958,7 @@ async function createDaemon(deps) {
       taskId: args.taskId,
       agentSystem: args.agentSystem,
       environmentKey: args.cwd,
-      pluginsDir: join78(deps.shipyardHome, "plugins"),
+      pluginsDir: join79(deps.shipyardHome, "plugins"),
       vizWatcher: getOrCreateVizWatcher(args.taskId).watcher,
       mode: "task",
       previewProxy: deps.previewProxy,
@@ -95738,7 +96096,7 @@ async function createDaemon(deps) {
       /** Claude in-process harness — Codex uses the HTTP path with 'codex' above. */
       agentSystem: AGENT_SYSTEM_CLAUDE_CODE,
       environmentKey: args.cwd,
-      pluginsDir: join78(deps.shipyardHome, "plugins"),
+      pluginsDir: join79(deps.shipyardHome, "plugins"),
       vizWatcher: args.vizWatcher,
       mode: args.mode ?? "task",
       previewProxy: deps.previewProxy,
@@ -96772,7 +97130,7 @@ async function createDaemon(deps) {
     deps.metricsCollector
   );
   const planDocGapReporter = startPlanDocPersistenceGapReporter({
-    loroDir: join78(deps.dataDir, "loro"),
+    loroDir: join79(deps.dataDir, "loro"),
     listTasks: () => taskStateStore.listTasks(),
     log: deps.log,
     metricsCollector: deps.metricsCollector
@@ -96788,7 +97146,7 @@ async function createDaemon(deps) {
   const stallProfilerConfig = getStallProfilerConfig();
   const stallProfiler = new StallProfiler({
     log: deps.log,
-    outDir: join78(deps.dataDir, "stall-profiles"),
+    outDir: join79(deps.dataDir, "stall-profiles"),
     thresholdMs: stallProfilerConfig.thresholdMs,
     captureMs: stallProfilerConfig.captureMs,
     rateLimitMs: stallProfilerConfig.rateLimitMs
@@ -97426,7 +97784,7 @@ import { existsSync as existsSync13 } from "fs";
 import { execFile as execFile11, spawn as spawn13 } from "child_process";
 import { createHash as createHash15 } from "crypto";
 import { chmod as chmod3, mkdir as mkdir37, readFile as readFile48, rename as rename21, unlink as unlink16, writeFile as writeFile30 } from "fs/promises";
-import { join as join79 } from "path";
+import { join as join80 } from "path";
 
 // src/services/bootstrap/self-update-installer-scripts.ts
 function buildPosixInstallerScript(params) {
@@ -97828,7 +98186,7 @@ async function downloadTarball(url, destPath, fetchFn) {
       throw new Error(`download failed: HTTP ${response.status} ${response.statusText}`);
     }
     const bytes = new Uint8Array(await response.arrayBuffer());
-    await mkdir37(join79(destPath, ".."), { recursive: true });
+    await mkdir37(join80(destPath, ".."), { recursive: true });
     try {
       await writeFile30(tmpPath, bytes);
       await rename21(tmpPath, destPath);
@@ -97858,7 +98216,7 @@ async function verifyChecksum(path5, expectedHash) {
   }
 }
 async function stageInstallerScript(scriptPath, params) {
-  await mkdir37(join79(scriptPath, ".."), { recursive: true });
+  await mkdir37(join80(scriptPath, ".."), { recursive: true });
   const body = process.platform === "win32" ? buildWindowsInstallerScript(params) : buildPosixInstallerScript(params);
   await writeFile30(scriptPath, body);
   await chmod3(scriptPath, 493);
@@ -97908,16 +98266,16 @@ function buildInstallerParams(state, deps) {
     targetVersion: state.resolved.version,
     previousVersion: deps.currentVersion,
     parentPid: deps.pid,
-    statusFilePath: join79(deps.shipyardHome, "update-status.json"),
-    pidFilePath: join79(deps.shipyardHome, "daemon.pid"),
-    logPath: join79(deps.shipyardHome, "updates", `install-${deps.pid}.log`),
-    snapshotPath: join79(deps.shipyardHome, "updates", `rollback-${deps.currentVersion}`),
+    statusFilePath: join80(deps.shipyardHome, "update-status.json"),
+    pidFilePath: join80(deps.shipyardHome, "daemon.pid"),
+    logPath: join80(deps.shipyardHome, "updates", `install-${deps.pid}.log`),
+    snapshotPath: join80(deps.shipyardHome, "updates", `rollback-${deps.currentVersion}`),
     npmBin: "npm"
   };
 }
 function tarballPathFor(shipyardHome, version, shasum) {
   const shaPrefix = shasum.slice(0, 12);
-  return join79(shipyardHome, "updates", `${version}-${shaPrefix}.tgz`);
+  return join80(shipyardHome, "updates", `${version}-${shaPrefix}.tgz`);
 }
 async function runResolveStep(step, state, deps) {
   const resolver = deps.resolveVersion ?? defaultResolveVersion;
@@ -99005,7 +99363,7 @@ function buildLocalDirectChannelCallbacks(deps) {
 
 // src/services/skills-cache/codex-skills-cache.ts
 import { mkdir as mkdir38, readFile as readFile49, rename as rename22, writeFile as writeFile31 } from "fs/promises";
-import { dirname as dirname38, join as join80 } from "path";
+import { dirname as dirname38, join as join81 } from "path";
 var CACHE_FILENAME = "codex-skills-cache.json";
 var SkillInfoCacheEntrySchema = external_exports.object({
   name: external_exports.string(),
@@ -99022,7 +99380,7 @@ var CodexSkillsCacheFileSchema = external_exports.object({
   skills: external_exports.array(SkillInfoCacheEntrySchema)
 });
 function defaultCodexSkillsCachePath(shipyardHome) {
-  return join80(shipyardHome, "state", CACHE_FILENAME);
+  return join81(shipyardHome, "state", CACHE_FILENAME);
 }
 async function loadCodexSkillsCache(path5) {
   let raw;
@@ -99086,11 +99444,11 @@ async function saveCodexSkillsCache(path5, cache2) {
 // src/services/skills-mirror/manager.ts
 import { lstat, mkdir as mkdir40, readlink, stat as stat18, symlink, unlink as unlink18 } from "fs/promises";
 import { homedir as homedir14 } from "os";
-import { dirname as dirname40, join as join82 } from "path";
+import { dirname as dirname40, join as join83 } from "path";
 
 // src/services/skills-mirror/manifest.ts
 import { mkdir as mkdir39, readFile as readFile50, rename as rename23, unlink as unlink17, writeFile as writeFile32 } from "fs/promises";
-import { dirname as dirname39, join as join81 } from "path";
+import { dirname as dirname39, join as join82 } from "path";
 var MANIFEST_VERSION = 1;
 var ManifestEntrySchema = external_exports.object({
   /** Display name of the skill (e.g. `qa`, or `plugin:name` when namespaced). */
@@ -99110,7 +99468,7 @@ function emptyManifest() {
   return { version: MANIFEST_VERSION, entries: [] };
 }
 function defaultManifestPath(shipyardHome) {
-  return join81(shipyardHome, "state", "skill-mirror-manifest.json");
+  return join82(shipyardHome, "state", "skill-mirror-manifest.json");
 }
 async function loadManifest(path5) {
   try {
@@ -99141,15 +99499,15 @@ async function deleteManifest(path5) {
 function defaultPaths() {
   const home = homedir14();
   return {
-    claudeSkillsDir: join82(home, ".claude", "skills"),
-    codexSkillsDir: join82(home, ".agents", "skills"),
+    claudeSkillsDir: join83(home, ".claude", "skills"),
+    codexSkillsDir: join83(home, ".agents", "skills"),
     manifestPath: defaultManifestPath(getShipyardHome())
   };
 }
 function plannedSymlinkPath(skill, paths) {
   const linkName = skill.namespace ? `${skill.namespace}:${skill.name}` : skill.name;
-  if (skill.sourceAgent === "claude-code") return join82(paths.codexSkillsDir, linkName);
-  if (skill.sourceAgent === "codex") return join82(paths.claudeSkillsDir, linkName);
+  if (skill.sourceAgent === "claude-code") return join83(paths.codexSkillsDir, linkName);
+  if (skill.sourceAgent === "codex") return join83(paths.claudeSkillsDir, linkName);
   return null;
 }
 function isPermissionError(err3) {
@@ -99362,7 +99720,7 @@ async function ensureMirror(skills, config, paths = defaultPaths()) {
 
 // src/services/skills-mirror/prefs.ts
 import { mkdir as mkdir41, readFile as readFile51, rename as rename24, writeFile as writeFile33 } from "fs/promises";
-import { dirname as dirname41, join as join83 } from "path";
+import { dirname as dirname41, join as join84 } from "path";
 var SkillsMirrorPrefsSchema = external_exports.object({
   enabled: external_exports.boolean().default(false)
 });
@@ -99371,7 +99729,7 @@ function defaultSkillsMirrorPrefs() {
   return { enabled: false };
 }
 function prefsPath(dataDir) {
-  return join83(dataDir, FILENAME);
+  return join84(dataDir, FILENAME);
 }
 async function loadSkillsMirrorPrefs(dataDir) {
   try {
@@ -99420,7 +99778,7 @@ async function reconcileSkillsMirror(args) {
 // src/services/storage/daemon-settings-store.ts
 import { createHash as createHash16 } from "crypto";
 import { mkdir as mkdir42, readFile as readFile52 } from "fs/promises";
-import { join as join84 } from "path";
+import { join as join85 } from "path";
 var ProjectSettingsSchema = external_exports.object({
   disabledMcpServers: external_exports.array(external_exports.string()).optional(),
   previewMigrationV36Done: external_exports.boolean().default(false)
@@ -99429,9 +99787,9 @@ function hashProjectPath(projectPath) {
   return createHash16("sha256").update(projectPath).digest("hex").slice(0, 16);
 }
 function buildDaemonSettingsStore(dataDir) {
-  const settingsDir = join84(dataDir, "settings");
+  const settingsDir = join85(dataDir, "settings");
   function settingsPath(projectPath) {
-    return join84(settingsDir, `${hashProjectPath(projectPath)}.json`);
+    return join85(settingsDir, `${hashProjectPath(projectPath)}.json`);
   }
   async function ensureDir() {
     await mkdir42(settingsDir, { recursive: true });
@@ -99456,12 +99814,12 @@ function buildDaemonSettingsStore(dataDir) {
 
 // src/services/storage/plugin-config-store.ts
 import { mkdir as mkdir43, readFile as readFile53 } from "fs/promises";
-import { join as join85 } from "path";
+import { join as join86 } from "path";
 function buildPluginConfigStore(pluginsDir) {
   const cache2 = /* @__PURE__ */ new Map();
   const writeQueues = /* @__PURE__ */ new Map();
   function configPath(pluginId) {
-    return join85(pluginsDir, pluginId, "config.json");
+    return join86(pluginsDir, pluginId, "config.json");
   }
   async function readConfigFromDisk(pluginId) {
     const fp = configPath(pluginId);
@@ -99515,7 +99873,7 @@ function buildPluginConfigStore(pluginsDir) {
           const fresh = await readConfigFromDisk(pluginId);
           fresh[key] = value;
           cache2.set(pluginId, fresh);
-          await mkdir43(join85(pluginsDir, pluginId), { recursive: true });
+          await mkdir43(join86(pluginsDir, pluginId), { recursive: true });
           await atomicWriteFile(configPath(pluginId), JSON.stringify(fresh, null, 2));
         })
       );
@@ -99761,7 +100119,7 @@ async function serve(options = {}) {
 }
 async function runServeBody(options, captureRefs) {
   const shipyardHome = options.shipyardHome ?? getShipyardHome();
-  const dataDir = join86(shipyardHome, options.isDev ? "data-dev" : "data");
+  const dataDir = join87(shipyardHome, options.isDev ? "data-dev" : "data");
   const log = createChildLogger({ mode: "serve" });
   log.info(
     { event: "daemon_start", version: getDaemonVersion(), pid: process.pid },
@@ -99769,7 +100127,7 @@ async function runServeBody(options, captureRefs) {
   );
   const { workspaceRoot, unscopedWorkspace, unscopedReason } = await resolveWorkspaceScope();
   registerBuiltinPlugins();
-  const pluginConfigStore = buildPluginConfigStore(join86(dataDir, "plugins"));
+  const pluginConfigStore = buildPluginConfigStore(join87(dataDir, "plugins"));
   await mkdir44(dataDir, { recursive: true });
   log.info(
     {
@@ -99862,9 +100220,9 @@ async function runServeBody(options, captureRefs) {
   await bootstrapPhase("pid_sweep_orphans", () => pidTracker.sweepOrphans(logAdapter));
   await bootstrapPhase(
     "legacy_epoch_prune",
-    () => pruneOldEpochData(join86(dataDir, "loro"), logAdapter)
+    () => pruneOldEpochData(join87(dataDir, "loro"), logAdapter)
   );
-  const storage = new FileStorageAdapter(join86(dataDir, "loro"));
+  const storage = new FileStorageAdapter(join87(dataDir, "loro"));
   const personalWebrtcAdapter = new WebRtcDataChannelAdapter();
   const peerRoleRegistry = createPeerRoleRegistry();
   const presencePoolRef = { pool: {} };
@@ -99973,14 +100331,14 @@ async function runServeBody(options, captureRefs) {
     current: []
   };
   const terminalPtys = /* @__PURE__ */ new Map();
-  const terminalLogsDir = join86(shipyardHome, "data", "terminals");
+  const terminalLogsDir = join87(shipyardHome, "data", "terminals");
   await mkdir44(terminalLogsDir, { recursive: true, mode: 448 });
   const publishedArtifactStore = createPublishedArtifactStore({
-    rootDir: join86(dataDir, "published"),
+    rootDir: join87(dataDir, "published"),
     log: logAdapter
   });
   const previewStateStore = createPreviewStateStore({
-    rootDir: join86(dataDir, "preview-state"),
+    rootDir: join87(dataDir, "preview-state"),
     logger: log
   });
   let codexSkillsApplyScopedPatchRef = null;
@@ -100065,7 +100423,7 @@ async function runServeBody(options, captureRefs) {
   daemon.healthMetrics.start();
   publishedArtifactStore.setSendControlMessage((msg) => daemon.taskManager.broadcastControl(msg));
   previewStateStore.setSendControlMessage((msg) => daemon.taskManager.broadcastControl(msg));
-  const pluginsDir = join86(shipyardHome, "plugins");
+  const pluginsDir = join87(shipyardHome, "plugins");
   await mkdir44(pluginsDir, { recursive: true });
   let loadedPlugins = [];
   const loadedPluginsRef = {
@@ -100261,6 +100619,7 @@ async function runServeBody(options, captureRefs) {
     }
   });
   const fileIOHandlers = /* @__PURE__ */ new Set();
+  const collabHostingStore = buildCollabHostingStore(dataDir);
   const collabRoomManager = signalingHandle ? buildCollabRoomManager({
     peerRoleRegistry,
     repo,
@@ -100281,13 +100640,22 @@ async function runServeBody(options, captureRefs) {
     fileWatcherPool,
     terminalPtys,
     terminalLogsDir,
-    housekeepingBarrier
+    housekeepingBarrier,
+    collabHostingStore
   }) : null;
   if (collabRoomManager) {
     daemon.setCollabParticipantsProvider(
       (taskId) => collabRoomManager.getParticipantsForTask(taskId)
     );
     daemon.setCollabActiveTaskIdsProvider(() => collabRoomManager.listActiveTaskIds());
+    startCollabRehydrate({
+      collabRoomManager,
+      store: collabHostingStore,
+      signalingBaseUrl: auth3.signalingUrl,
+      userToken: auth3.token,
+      machineId: daemonPeerId,
+      log: logAdapter
+    });
   }
   const portDetectorRef = { current: null };
   const onAttachDataChannelFailed = createAttachFailureCanary(log, logAdapter);
@@ -100626,4 +100994,4 @@ export {
   decideWorkspaceScope,
   serve
 };
-//# sourceMappingURL=serve-RW42I4NC.js.map
+//# sourceMappingURL=serve-25I4ML7R.js.map