@schoolai/shipyard 3.2.1 → 3.2.2-nightly.20260422.0

package/dist/{serve-P5WC5JIT.js → serve-X4R5CDHD.js}

@@ -47,11 +47,11 @@ import {
   VaultKeyPutRequestSchema,
   VaultKeyPutResponseSchema,
   classifyClaudeCodeCompatibility
-} from "./chunk-FMMRZTOF.js";
+} from "./chunk-YZVF3NFD.js";
 import "./chunk-EHQITHQX.js";
 import {
   loadAuthToken
-} from "./chunk-IHSXN66C.js";
+} from "./chunk-GLH3V7NG.js";
 import {
   DiscoveryStateSchema,
   detectMCPServers,
@@ -62,19 +62,19 @@ import {
   redactEnv,
   resolveEnabledMcpServers,
   resolveStdioEnv
-} from "./chunk-Q6ZPJJM4.js";
+} from "./chunk-67VJDX7G.js";
 import {
   createChildLogger,
   flushLogger,
   logger
-} from "./chunk-3UYLOJ6E.js";
+} from "./chunk-DNIC3FOH.js";
 import {
   external_exports,
   getShipyardHome,
   isVanillaAgentMode,
   toJSONSchema,
   validateEnv
-} from "./chunk-CF336H24.js";
+} from "./chunk-M5M6VC5F.js";
 import {
   detectSkills
 } from "./chunk-DPMRSLYJ.js";
@@ -87,7 +87,7 @@ import { mkdir as mkdir24, realpath as realpath2 } from "fs/promises";
 import { join as join55 } from "path";
 import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
 
-// ../../node_modules/.pnpm/@loro-extended+change@6.0.0-beta.0_loro-crdt@1.10.6/node_modules/@loro-extended/change/dist/index.js
+// ../../node_modules/.pnpm/@loro-extended+change@6.0.0-beta.0_loro-crdt@1.11.1/node_modules/@loro-extended/change/dist/index.js
 import { LoroDoc } from "loro-crdt";
 import { isContainer, isContainerId } from "loro-crdt";
 import {
@@ -5226,7 +5226,7 @@ function getImplicitContext() {
   return result;
 }
 
-// ../../node_modules/.pnpm/@loro-extended+repo@6.0.0-beta.0_loro-crdt@1.10.6/node_modules/@loro-extended/repo/dist/index.js
+// ../../node_modules/.pnpm/@loro-extended+repo@6.0.0-beta.0_loro-crdt@1.11.1/node_modules/@loro-extended/repo/dist/index.js
 import { LoroDoc as LoroDoc2 } from "loro-crdt";
 import { VersionVector } from "loro-crdt";
 import { VersionVector as VersionVector2 } from "loro-crdt";
@@ -6941,7 +6941,7 @@ var makeCreator = (arg) => {
 var create = makeCreator();
 var constructorString = Object.prototype.constructor.toString();
 
-// ../../node_modules/.pnpm/@loro-extended+repo@6.0.0-beta.0_loro-crdt@1.10.6/node_modules/@loro-extended/repo/dist/index.js
+// ../../node_modules/.pnpm/@loro-extended+repo@6.0.0-beta.0_loro-crdt@1.11.1/node_modules/@loro-extended/repo/dist/index.js
 import { EphemeralStore } from "loro-crdt";
 import {
   LoroDoc as LoroDoc22
@@ -12461,7 +12461,7 @@ function encodeCBOR(data) {
   return output;
 }
 
-// ../../node_modules/.pnpm/@loro-extended+wire-format@0.1.1-beta.0_loro-crdt@1.10.6/node_modules/@loro-extended/wire-format/dist/index.js
+// ../../node_modules/.pnpm/@loro-extended+wire-format@0.1.1-beta.0_loro-crdt@1.11.1/node_modules/@loro-extended/wire-format/dist/index.js
 import { VersionVector as VersionVector4 } from "loro-crdt";
 var WIRE_VERSION = 2;
 var HEADER_SIZE = 6;
@@ -13249,7 +13249,7 @@ var FragmentReassembler = class {
   }
 };
 
-// ../../node_modules/.pnpm/@loro-extended+adapter-webrtc@6.0.0-beta.0_loro-crdt@1.10.6/node_modules/@loro-extended/adapter-webrtc/dist/index.js
+// ../../node_modules/.pnpm/@loro-extended+adapter-webrtc@6.0.0-beta.0_loro-crdt@1.11.1/node_modules/@loro-extended/adapter-webrtc/dist/index.js
 var DEFAULT_FRAGMENT_THRESHOLD = 200 * 1024;
 var WebRtcDataChannelAdapter = class extends Adapter {
   /**
@@ -29036,7 +29036,7 @@ function resolveTaskIdFromResult(resultText) {
   return match2?.[1] ?? null;
 }
 function ccFileToStructuredTask(file) {
-  const now = Date.now();
+  const createdAt = file.createdAt ?? 0;
   return {
     id: file.id,
     subject: file.subject,
@@ -29046,8 +29046,8 @@ function ccFileToStructuredTask(file) {
     owner: file.owner,
     blocks: file.blocks,
     blockedBy: file.blockedBy,
-    createdAt: file.createdAt ?? now,
-    updatedAt: file.updatedAt ?? now
+    createdAt,
+    updatedAt: file.updatedAt ?? createdAt
   };
 }
 var CC_STATUS_MAP = {
@@ -29719,8 +29719,12 @@ async function detectModels() {
   try {
     await run("which", ["claude"]);
     const supported = getSupportedEfforts();
-    const filter = (efforts) => efforts.filter((e) => supported.has(e));
-    const pickDefault = (desired, efforts) => efforts.includes(desired) ? desired : efforts[efforts.length - 1] ?? "low";
+    const filter = (efforts) => efforts.filter((e) => e === "auto" || supported.has(e));
+    const pickDefault = (desired, efforts) => {
+      if (efforts.includes(desired)) return desired;
+      const concrete = efforts.filter((e) => e !== "auto");
+      return concrete[concrete.length - 1] ?? "low";
+    };
     const opusEfforts = filter(["low", "medium", "high", "xhigh", "max", "auto"]);
     const sonnetEfforts = filter(["low", "medium", "high", "max", "auto"]);
     models.push(
@@ -31450,7 +31454,7 @@ function nanoid(size2 = 21) {
 }
 
 // src/services/bootstrap/signaling.ts
-var DAEMON_NPM_VERSION = true ? "3.2.1" : "unknown";
+var DAEMON_NPM_VERSION = true ? "3.2.2" : "unknown";
 function createDaemonSignaling(config2) {
   const agentId = config2.agentId ?? nanoid();
   function send(msg) {
@@ -37227,12 +37231,19 @@ var SANDBOX_COLOR_PALETTE = `## Color Palette
 - Group by **category**, not sequence. All items of one type share one ramp.
 - Gray for neutral/structural elements.
 - Reserve blue/green/red for semantic meaning (info, success, danger). Use teal, amber, coral for general categories.
-- When placing text on a colored background (badges, pills, cards, tags), use the darkest stop from that same color ramp for the text \u2014 never plain black or generic gray.
+- When placing text on a colored background (badges, pills, cards, tags), use a stop from the far end of the same ramp: on a light fill (stop 50) use stop 800 for text; on a dark fill (stop 800) use stop 50 or 200 for text. Never plain black or generic gray.
 
 **Light/dark mode stop assignment** \u2014 use only stops from the table, never off-table hex values:
 - **Light mode**: 50 fill + 600 stroke + **800 title / 600 subtitle**
-- **Dark mode**: 800 fill + 200 stroke + **200 title / 400 subtitle**
+- **Dark mode**: 800 fill + 200 stroke + **50 title / 200 subtitle**
 - Title and subtitle MUST use different stops \u2014 same stop reads flat even with different font weights. When a box has both a title and subtitle, the weight difference alone is not enough; you need two distinct color stops for visual hierarchy.
+- Never use stop 400 as body text in either mode \u2014 it's a mid-tone that fails WCAG AA (~3:1) on near-white or near-black page backgrounds. Stop 400 is fine as a fill or as text on a 50/200 background; just not as text on the page bg.
+- Stop 600 is tuned for light-mode subtitles on 50 fills \u2014 do not reach for it as text in dark mode, where it approaches the 800 fill and reads muddy.
+- For muted text, always use \`var(--text-muted)\` \u2014 never a hand-picked gray hex (e.g. gray-400/600) as a muted substitute.
+
+**Container contrast on dark mode** \u2014 an 800-fill box on a near-black page bg nearly disappears (gray-800 on gray-950 reads at ~1.8:1 container-vs-bg). When placing 800-fill boxes in dark mode, do ONE of:
+- Add a stroke using stop 200 from the same ramp (recommended \u2014 the 200 stroke is luminous enough to define the container edge).
+- Place the box on \`var(--bg-surface)\` or \`var(--bg-overlay)\` instead of the raw page bg.
 
 **Dark mode is mandatory** \u2014 mental test: if the background were near-black, would every text element still be readable? Always use \`var(--text)\` or \`var(--text-muted)\` for text, never hardcoded dark colors.`;
 var SANDBOX_ANTI_SLOP = `## Design Quality
@@ -50290,7 +50301,7 @@ var PluginKey = class {
 // src/services/plan/plan-content-bridge.ts
 import { LoroMap as LoroMap4 } from "loro-crdt";
 
-// ../../node_modules/.pnpm/loro-prosemirror@0.4.2_loro-crdt@1.10.6_prosemirror-model@1.25.4_prosemirror-state@1.4.4_prosemirror-view@1.41.6/node_modules/loro-prosemirror/dist/index.mjs
+// ../../node_modules/.pnpm/loro-prosemirror@0.4.2_loro-crdt@1.11.1_prosemirror-model@1.25.4_prosemirror-state@1.4.4_prosemirror-view@1.41.6/node_modules/loro-prosemirror/dist/index.mjs
 import { LoroMap as LoroMap3, LoroText as LoroText3, LoroList as LoroList3, isContainer as isContainer2, EphemeralStore as EphemeralStore2, Cursor, Awareness, UndoManager } from "loro-crdt";
 
 // ../../node_modules/.pnpm/prosemirror-view@1.41.6/node_modules/prosemirror-view/dist/index.js
@@ -55621,7 +55632,7 @@ var simpleDiffString = (a, b2) => {
 };
 var simpleDiff = simpleDiffString;
 
-// ../../node_modules/.pnpm/loro-prosemirror@0.4.2_loro-crdt@1.10.6_prosemirror-model@1.25.4_prosemirror-state@1.4.4_prosemirror-view@1.41.6/node_modules/loro-prosemirror/dist/index.mjs
+// ../../node_modules/.pnpm/loro-prosemirror@0.4.2_loro-crdt@1.11.1_prosemirror-model@1.25.4_prosemirror-state@1.4.4_prosemirror-view@1.41.6/node_modules/loro-prosemirror/dist/index.mjs
 var ROOT_DOC_KEY = "doc";
 var ATTRIBUTES_KEY = "attributes";
 var CHILDREN_KEY = "children";
@@ -72907,10 +72918,27 @@ function hasErrorCode(err, code2) {
   const record = err;
   return record.code === code2;
 }
+function isCliFlagEffort(effort) {
+  switch (effort) {
+    case "low":
+    case "medium":
+    case "high":
+    case "xhigh":
+    case "max":
+      return true;
+    case "auto":
+      return false;
+    default: {
+      const _exhaustive = effort;
+      return _exhaustive;
+    }
+  }
+}
 var FALLBACK_PRIORITY = ["high", "max", "medium", "low"];
 var warnedEffortCoercions = /* @__PURE__ */ new Set();
 function resolveSupportedEffort(effort, log) {
   if (!effort) return void 0;
+  if (!isCliFlagEffort(effort)) return void 0;
   const supported = getSupportedEfforts();
   if (supported.has(effort)) return effort;
   const fallback = FALLBACK_PRIORITY.find((e) => supported.has(e));
@@ -85417,7 +85445,7 @@ var PlanHandler = class {
     this.#deps.enqueueAsync(async () => {
       try {
         await this.#preparePlanForResolution(toolUseId, opts?.comments ?? []);
-        await this.#applyPermissionMode(opts?.permissionMode);
+        this.#applyPermissionMode(opts?.permissionMode);
       } catch (err) {
         this.#deps.log({
           event: "plan_continue_preparation_failed",
@@ -85682,14 +85710,9 @@ var PlanHandler = class {
       });
     });
   }
-  async #applyPermissionMode(permissionMode) {
+  #applyPermissionMode(permissionMode) {
     if (!permissionMode) return;
-    this.#deps.setLatestSettings({ permissionMode });
-    await this.#deps.getSubprocess()?.setPermissionMode(permissionMode);
-    this.#deps.getSendControlMessage()?.({
-      type: "settings_ack",
-      settings: { permissionMode }
-    });
+    this.#deps.applyTaskSettings({ permissionMode });
   }
   async #injectDecisionMessage(decision, feedback) {
     const reviewer = this.#deps.getHumanParticipantName();
@@ -86274,6 +86297,22 @@ function planCompactionSnapshot(input) {
 }
 
 // src/services/task/resource-push-manager.ts
+async function writeResourceSynthetics(deps, messages) {
+  const allContent = [];
+  for (const msg of messages) {
+    await deps.store.appendMessage({
+      channelId: deps.channelId,
+      messageId: crypto.randomUUID(),
+      participantId: deps.humanParticipantId,
+      senderKind: "human",
+      content: msg.content,
+      timestamp: Date.now(),
+      isSynthetic: true
+    });
+    for (const block2 of msg.content) allContent.push(block2);
+  }
+  return allContent;
+}
 var MAX_PUSHES_PER_TURN = 3;
 var ResourcePushManager = class {
   #deps;
@@ -86424,20 +86463,14 @@ var ResourcePushManager = class {
     });
   }
   async #writeSynthetics(messages) {
-    const allContent = [];
-    for (const msg of messages) {
-      await this.#deps.store.appendMessage({
+    return writeResourceSynthetics(
+      {
+        store: this.#deps.store,
         channelId: this.#deps.channelId,
-        messageId: crypto.randomUUID(),
-        participantId: this.#deps.humanParticipantId,
-        senderKind: "human",
-        content: msg.content,
-        timestamp: Date.now(),
-        isSynthetic: true
-      });
-      for (const block2 of msg.content) allContent.push(block2);
-    }
-    return allContent;
+        humanParticipantId: this.#deps.humanParticipantId
+      },
+      messages
+    );
   }
   #deliverToSubprocess(allContent, uriCount) {
     const state = this.#deps.getState();
@@ -87284,6 +87317,9 @@ var SideThreadRegistry = class {
     );
     entry.thread = thread;
     this.#threads.set(params.threadId, entry);
+    if (params.initialPermissionMode !== void 0) {
+      thread.applyPermissionMode(params.initialPermissionMode);
+    }
     this.#persist().catch((err) => {
       const errMsg = err instanceof Error ? err.message : String(err);
       this.#deps.log({
@@ -88002,7 +88038,7 @@ async function removeStaleFiles(dir, targetIds, hashes) {
   }
   for (const entry of entries) {
     if (!entry.endsWith(".json")) continue;
-    const id = entry.replace(".json", "");
+    const id = entry.slice(0, -".json".length);
     if (!targetIds.has(id) && hashes.has(id)) {
       await unlink7(join41(dir, entry)).catch(() => {
       });
@@ -88010,14 +88046,15 @@ async function removeStaleFiles(dir, targetIds, hashes) {
     }
   }
 }
-function createCCTaskFileWriter(dir, log) {
+function createCCTaskFileWriter(initialDir, log) {
   const lastWrittenHashes = /* @__PURE__ */ new Map();
+  let currentDir = initialDir;
   let debounceTimer = null;
   let pendingTasks = null;
   let disposed = false;
   let flushInProgress = Promise.resolve();
   const DEBOUNCE_MS3 = 200;
-  async function flush(tasks) {
+  async function flush(dir, tasks) {
     if (disposed) return;
     try {
       await mkdir17(dir, { recursive: true });
@@ -88033,7 +88070,7 @@ function createCCTaskFileWriter(dir, log) {
       });
     }
   }
-  function scheduleFlush(tasks) {
+  function scheduleFlush(dir, tasks) {
     pendingTasks = tasks;
     if (debounceTimer) clearTimeout(debounceTimer);
     debounceTimer = setTimeout(() => {
@@ -88041,19 +88078,42 @@ function createCCTaskFileWriter(dir, log) {
       const snapshot = pendingTasks;
       pendingTasks = null;
       if (snapshot) {
-        flushInProgress = flushInProgress.then(() => flush(snapshot));
+        flushInProgress = flushInProgress.then(() => flush(dir, snapshot));
       }
     }, DEBOUNCE_MS3);
   }
   return {
-    dir,
+    get dir() {
+      return currentDir;
+    },
     writeMergedTasks(tasks) {
       if (disposed) return;
-      scheduleFlush(tasks);
+      if (currentDir === null) {
+        pendingTasks = tasks;
+        return;
+      }
+      scheduleFlush(currentDir, tasks);
+    },
+    async setDir(dir) {
+      if (disposed) return;
+      if (currentDir !== null) return;
+      currentDir = dir;
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+      const snapshot = pendingTasks;
+      pendingTasks = null;
+      if (snapshot) {
+        const flushPromise = flush(dir, snapshot);
+        flushInProgress = flushInProgress.then(() => flushPromise);
+        await flushPromise;
+      }
     },
     dispose() {
       disposed = true;
       if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = null;
       pendingTasks = null;
     }
   };
@@ -88105,6 +88165,39 @@ function applyDepEdgeAdditions(merged, depEdges) {
     }
   }
 }
+function applyOverlayToMap(base3, overlay) {
+  const merged = new Map(base3);
+  for (const userTask of overlay.userTasks) {
+    const baseTask = merged.get(userTask.id);
+    if (!baseTask || baseTask.updatedAt <= userTask.updatedAt) {
+      merged.set(userTask.id, userTask);
+    }
+  }
+  for (const id of overlay.removedIds) merged.delete(id);
+  for (const [id, status] of Object.entries(overlay.statusOverrides)) {
+    const task = merged.get(id);
+    if (task) merged.set(id, { ...task, status });
+  }
+  applyDepEdgeRemovals(merged, overlay.removedDepEdges);
+  applyDepEdgeAdditions(merged, overlay.depEdges);
+  return merged;
+}
+function computeTodoProgress(tasks) {
+  if (tasks.size === 0) return void 0;
+  let completed = 0;
+  let currentActivity = null;
+  for (const task of tasks.values()) {
+    if (task.status === "completed" || task.status === "cancelled") completed++;
+    if (task.status === "in_progress" && !currentActivity) {
+      currentActivity = task.activeForm ?? task.subject;
+    }
+  }
+  return {
+    todoCompleted: completed,
+    todoTotal: tasks.size,
+    currentActivity
+  };
+}
 var StructuredTaskTracker = class {
   #deps;
   #structuredTasks = /* @__PURE__ */ new Map();
@@ -88114,9 +88207,12 @@ var StructuredTaskTracker = class {
   #currentOverlay = null;
   #ccTaskWatcherDispose = null;
   #suppressWriteThrough = false;
-  #ccTaskFileWriter = null;
+  #ccTaskFileWriter;
+  #restoreInProgress = false;
   constructor(deps) {
     this.#deps = deps;
+    this.#ccTaskFileWriter = createCCTaskFileWriter(null, deps.log);
+    this.#restoreInProgress = deps.restoreInProgress ?? false;
   }
   get currentOverlay() {
     return this.#currentOverlay;
@@ -88124,8 +88220,7 @@ var StructuredTaskTracker = class {
   dispose() {
     this.#ccTaskWatcherDispose?.();
     this.#ccTaskWatcherDispose = null;
-    this.#ccTaskFileWriter?.dispose();
-    this.#ccTaskFileWriter = null;
+    this.#ccTaskFileWriter.dispose();
   }
   clearInMemoryTasks() {
     this.#structuredTasks.clear();
@@ -88136,14 +88231,14 @@ var StructuredTaskTracker = class {
   detachFileWatcher() {
     this.#ccTaskWatcherDispose?.();
     this.#ccTaskWatcherDispose = null;
-    this.#ccTaskFileWriter?.dispose();
-    this.#ccTaskFileWriter = null;
+    this.#ccTaskFileWriter.dispose();
+    this.#ccTaskFileWriter = createCCTaskFileWriter(null, this.#deps.log);
   }
   /**
    * Attach a file watcher for CC task files. Called after init_received
    * when we know the CC session ID, or immediately for resumed sessions.
    */
-  attachFileWatcher(sessionId) {
+  async attachFileWatcher(sessionId) {
     if (this.#ccTaskWatcherDispose) {
       this.#deps.log({
         event: "file_watcher_already_attached",
@@ -88153,7 +88248,7 @@ var StructuredTaskTracker = class {
       return;
     }
     const watcher = createCCTaskFileWatcher(sessionId, this.#deps.log);
-    this.#ccTaskFileWriter = createCCTaskFileWriter(watcher.dir, this.#deps.log);
+    await this.#ccTaskFileWriter.setDir(watcher.dir);
     this.#initFileWatcher(watcher);
     if (this.#currentOverlay) {
       this.#flushStructuredTasks();
@@ -88161,9 +88256,24 @@ var StructuredTaskTracker = class {
   }
   /**
    * Apply an overlay on top of CC tasks. Stores the overlay and re-flushes.
+   * Exits restore mode — applyOverlay is the terminal piece of restoration
+   * (disk reconcile is idempotent with the seeded overlay, so we flush once
+   * here with full inputs instead of producing a partial pre-overlay flush).
    */
   applyOverlay(overlay) {
     this.#currentOverlay = overlay;
+    this.#restoreInProgress = false;
+    this.#flushStructuredTasks();
+  }
+  /**
+   * Signal that restoration has finished for tasks that have no persisted
+   * overlay to apply. Unblocks #flushStructuredTasks and runs one flush with
+   * the current state (disk-only, no overlay). Must be called by the
+   * restoration caller whenever applyOverlay will not be invoked.
+   */
+  markRestoreComplete() {
+    if (!this.#restoreInProgress) return;
+    this.#restoreInProgress = false;
     this.#flushStructuredTasks();
   }
   processStructuredTaskEvents(content) {
@@ -88272,48 +88382,16 @@ var StructuredTaskTracker = class {
    * 6. Compute todo progress from the merged result
    * 7. Push to updateStructuredTasks
    */
-  #applyOverlayToMap(base3, overlay) {
-    const merged = new Map(base3);
-    for (const userTask of overlay.userTasks) {
-      const baseTask = merged.get(userTask.id);
-      if (!baseTask || baseTask.updatedAt <= userTask.updatedAt) {
-        merged.set(userTask.id, userTask);
-      }
-    }
-    for (const id of overlay.removedIds) merged.delete(id);
-    for (const [id, status] of Object.entries(overlay.statusOverrides)) {
-      const task = merged.get(id);
-      if (task) merged.set(id, { ...task, status, updatedAt: Date.now() });
-    }
-    applyDepEdgeRemovals(merged, overlay.removedDepEdges);
-    applyDepEdgeAdditions(merged, overlay.depEdges);
-    return merged;
-  }
   #flushStructuredTasks() {
+    if (this.#restoreInProgress) return;
     const overlay = this.#currentOverlay ?? DEFAULT_TASK_OVERLAY;
-    const merged = this.#applyOverlayToMap(this.#structuredTasks, overlay);
-    const todoProgress = this.#computeTodoProgress(merged);
+    const merged = applyOverlayToMap(this.#structuredTasks, overlay);
+    const todoProgress = computeTodoProgress(merged);
     this.#deps.updateStructuredTasks(Object.fromEntries(merged), todoProgress);
     if (!this.#suppressWriteThrough) {
-      this.#ccTaskFileWriter?.writeMergedTasks(merged);
+      this.#ccTaskFileWriter.writeMergedTasks(merged);
     }
   }
-  #computeTodoProgress(tasks) {
-    if (tasks.size === 0) return void 0;
-    let completed = 0;
-    let currentActivity = null;
-    for (const task of tasks.values()) {
-      if (task.status === "completed" || task.status === "cancelled") completed++;
-      if (task.status === "in_progress" && !currentActivity) {
-        currentActivity = task.activeForm ?? task.subject;
-      }
-    }
-    return {
-      todoCompleted: completed,
-      todoTotal: tasks.size,
-      currentActivity
-    };
-  }
   #initFileWatcher(watcher) {
     this.#ccTaskWatcherDispose = watcher.watch((tasks) => {
       this.#reconcileFromDisk(tasks);
@@ -89509,7 +89587,8 @@ var Task = class {
     this.#structuredTaskTracker = new StructuredTaskTracker({
       taskId: deps.taskId,
       log: deps.log,
-      updateStructuredTasks: deps.updateStructuredTasks
+      updateStructuredTasks: deps.updateStructuredTasks,
+      restoreInProgress: deps.restoreInProgress ?? false
     });
     this.#pushManager = new ResourcePushManager({
       taskId: deps.taskId,
@@ -89545,7 +89624,15 @@ var Task = class {
       queueKey: mainQueueKey(deps.taskId)
     });
     if (deps.existingSessionId) {
-      this.#structuredTaskTracker.attachFileWatcher(deps.existingSessionId);
+      const sessionIdForLog = deps.existingSessionId;
+      this.#structuredTaskTracker.attachFileWatcher(sessionIdForLog).catch((err) => {
+        deps.log({
+          event: "attach_file_watcher_failed",
+          taskId: deps.taskId,
+          sessionId: sessionIdForLog,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
     }
     this.#subagentManager = new SubagentManager({
       taskId: deps.taskId,
@@ -89578,10 +89665,6 @@ var Task = class {
       humanParticipantId: deps.humanParticipantId,
       planRepo: deps.planRepo,
       annotationStore: deps.annotationStore,
-      /** Delegate to Thread's encapsulated setPermissionMode */
-      getSubprocess: () => ({
-        setPermissionMode: (mode) => this.#mainThread?.setSubprocessPermissionMode(mode) ?? Promise.resolve()
-      }),
       getSendControlMessage: () => this.#broadcastToAllPeers,
       /**
        * Route PlanHandler messages through the permission queue so they
@@ -89599,12 +89682,7 @@ var Task = class {
       log: deps.log,
       metricsCollector: deps.metricsCollector,
       getLatestSettings: () => this.#latestSettings,
-      setLatestSettings: (patch) => {
-        this.#latestSettings = { ...this.#latestSettings, ...patch };
-        if (patch.permissionMode) {
-          this.#mainThread?.applyPermissionMode(patch.permissionMode);
-        }
-      },
+      applyTaskSettings: (settings) => this.#deps.applyTaskSettings(settings),
       pushSyntheticMessage: (content) => {
         this.#mainThread?.pushSyntheticMessage(content);
       },
@@ -90039,19 +90117,35 @@ var Task = class {
     return count + collabCount;
   }
   applyPermissionMode(mode) {
-    this.#latestSettings = {
-      ...this.#latestSettings,
-      permissionMode: mode
-    };
-    this.#mainThread.applyPermissionMode(mode);
+    this.applySettings({ permissionMode: mode });
   }
   applySettings(settings) {
     this.#latestSettings = { ...this.#latestSettings, ...settings };
-    if (settings.permissionMode) {
-      this.#mainThread.applyPermissionMode(settings.permissionMode);
+    if (settings.permissionMode !== void 0) {
+      const mode = settings.permissionMode;
+      this.#mainThread.applyPermissionMode(mode);
+      this.#propagateToSideThreads(
+        (t) => t.applyPermissionMode(mode),
+        "side_thread_permission_mode_failed"
+      );
+    }
+    if (settings.model !== void 0) {
+      const model = settings.model;
+      this.#mainThread.setModel(model);
+      this.#propagateToSideThreads((t) => t.setModel(model), "side_thread_model_failed");
     }
-    if (settings.model) {
-      this.#mainThread.setModel(settings.model);
+  }
+  #propagateToSideThreads(action, event) {
+    for (const thread of this.#sideThreads.liveThreads()) {
+      try {
+        action(thread);
+      } catch (err) {
+        this.#deps.log({
+          event,
+          taskId: this.#deps.taskId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
     }
   }
   async setMcpServers(servers) {
@@ -90505,7 +90599,10 @@ var Task = class {
     return this.#sideThreads.getMetadata(threadId);
   }
   createSideThread(params) {
-    return this.#sideThreads.create(params);
+    return this.#sideThreads.create({
+      ...params,
+      initialPermissionMode: params.initialPermissionMode ?? this.#latestSettings.permissionMode
+    });
   }
   async listSideThreads() {
     return this.#sideThreads.list();
@@ -90676,13 +90773,21 @@ Use this context to maintain continuity. You have already done this work \u2014
     try {
       const taskResource = await registry.resolve(taskUri);
       if ("text" in taskResource && !taskResource.text.includes('task-count="0"')) {
-        this.#pushManager.markPushed(taskUri);
         const rootMsg = buildRootMessage(
           taskUri,
           taskResource,
           "Task Plan",
           (/* @__PURE__ */ new Date()).toISOString()
         );
+        await writeResourceSynthetics(
+          {
+            store: this.#deps.store,
+            channelId: this.#deps.channelId,
+            humanParticipantId: this.#deps.humanParticipantId
+          },
+          [rootMsg]
+        );
+        this.#pushManager.markPushed(taskUri);
         return rootMsg.content;
       }
     } catch {
@@ -90798,7 +90903,14 @@ Use this context to maintain continuity. You have already done this work \u2014
         {
           const sessionId = this.#mainThread.sessionId;
           if (sessionId) {
-            this.#structuredTaskTracker.attachFileWatcher(sessionId);
+            this.#structuredTaskTracker.attachFileWatcher(sessionId).catch((err) => {
+              this.#deps.log({
+                event: "attach_file_watcher_failed",
+                taskId: this.#deps.taskId,
+                sessionId,
+                error: err instanceof Error ? err.message : String(err)
+              });
+            });
           }
         }
         this.#pushManager.onTurnStart();
@@ -91162,6 +91274,10 @@ Use this context to maintain continuity. You have already done this work \u2014
   applyOverlay(overlay) {
     this.#structuredTaskTracker.applyOverlay(overlay);
   }
+  /** See StructuredTaskTracker.markRestoreComplete. */
+  markStructuredTaskRestoreComplete() {
+    this.#structuredTaskTracker.markRestoreComplete();
+  }
   /** ---------------------------------------------------------------- */
   /** Resource resolution                                              */
   /** ---------------------------------------------------------------- */
@@ -91643,6 +91759,7 @@ function buildInitialOverlayFromTemplate(template, now) {
     subject: item2.content,
     description: item2.description,
     status: "pending",
+    owner: "user",
     blocks: [],
     blockedBy: item2.deps,
     createdAt: now,
@@ -91650,18 +91767,21 @@ function buildInitialOverlayFromTemplate(template, now) {
   }));
   return { ...DEFAULT_TASK_OVERLAY, userTasks };
 }
-function applyInitialOverlayToOrchestrator(args) {
-  const { taskId, initialOverlay, orchestratorRef, isTaskRegistered } = args;
-  if (orchestratorRef && isTaskRegistered(taskId)) {
-    orchestratorRef.applyOverlay(initialOverlay);
-    args.notifyTaskResourceChange(taskId);
+async function applyInitialOverlayToOrchestrator(args) {
+  const { taskId, initialOverlay, orchestratorRef, isTaskRegistered, taskStateStore } = args;
+  if (!orchestratorRef || !isTaskRegistered(taskId)) {
+    args.log({
+      event: "initial_overlay_skipped",
+      taskId,
+      reason: orchestratorRef ? "task_removed" : "orchestrator_not_registered"
+    });
     return;
   }
-  args.log({
-    event: "initial_overlay_skipped",
-    taskId,
-    reason: orchestratorRef ? "task_removed" : "orchestrator_not_registered"
-  });
+  orchestratorRef.applyOverlay(initialOverlay);
+  const merged = applyOverlayToMap(/* @__PURE__ */ new Map(), initialOverlay);
+  const todoProgress = computeTodoProgress(merged);
+  await taskStateStore.updateStructuredTasks(taskId, Object.fromEntries(merged), todoProgress);
+  args.notifyTaskResourceChange(taskId);
 }
 
 // src/services/task/manager/task-manager.ts
@@ -91931,6 +92051,7 @@ var TaskManager = class {
     task.orchestrator.applyPermissionMode(mode);
   }
   applyTaskSettings(taskId, settings) {
+    if (Object.keys(settings).length === 0) return;
     const composerPatch = {};
     if (settings.model !== void 0) composerPatch.model = settings.model;
     if (settings.reasoningEffort !== void 0)
@@ -91948,8 +92069,12 @@ var TaskManager = class {
       });
     }
     const task = this.#tasks.get(taskId);
-    if (!task) return;
+    if (!task) {
+      this.#deps.log({ event: "task_settings_no_orchestrator", taskId });
+      return;
+    }
     task.orchestrator.applySettings(settings);
+    this.broadcastControl({ type: "settings_ack", settings, taskId });
   }
   getPermissionMode(taskId) {
     const task = this.#tasks.get(taskId);
@@ -92021,12 +92146,13 @@ var TaskManager = class {
         initialOverlay
       });
       if (initialOverlay) {
-        applyInitialOverlayToOrchestrator({
+        await applyInitialOverlayToOrchestrator({
           taskId: params.taskId,
           initialOverlay,
           orchestratorRef,
           isTaskRegistered: (id) => this.#tasks.has(id),
           notifyTaskResourceChange: this.#deps.notifyTaskResourceChange,
+          taskStateStore: this.#deps.taskStateStore,
           log: this.#deps.log
         });
       }
@@ -92082,6 +92208,27 @@ var TaskManager = class {
     if (this.#tasks.has(taskId)) return;
     const cwd = opts.cwd;
     const mode = opts.mode ?? "task";
+    let orchestratorRef = null;
+    const restoreHydration = async () => {
+      const record = await this.#deps.taskStateStore.getTask(taskId);
+      if (!orchestratorRef || !this.#tasks.has(taskId)) return;
+      if (record?.taskOverlay) {
+        orchestratorRef.applyOverlay(record.taskOverlay);
+      } else {
+        orchestratorRef.markStructuredTaskRestoreComplete();
+      }
+      if (record?.composerSettings) {
+        applyPersistedComposerSettings(orchestratorRef, record.composerSettings);
+      }
+    };
+    const hydrationPromise = restoreHydration().catch((err) => {
+      this.#deps.log({
+        event: "overlay_restore_failed",
+        taskId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      orchestratorRef?.markStructuredTaskRestoreComplete();
+    });
     const orchestrator = this.#createTask(taskId, channelId, {
       initialState: opts.initialState,
       existingSessionId: opts.existingSessionId,
@@ -92091,21 +92238,15 @@ var TaskManager = class {
       initialTokenCount: opts.initialTokenCount,
       initialPlanDetection: opts.initialPlanDetection,
       mode,
+      hydrationPromise,
       initialRoiStartedEmitted: opts.initialRoiStartedEmitted,
       taskCreatedAt: opts.taskCreatedAt,
-      initialTurnCount: opts.initialTurnCount
+      initialTurnCount: opts.initialTurnCount,
+      restoreInProgress: true
     });
+    orchestratorRef = orchestrator;
     this.#tasks.set(taskId, { taskId, channelId, cwd, mode, orchestrator });
     this.#flushPendingStreamSubs(taskId, orchestrator);
-    this.#deps.taskStateStore.getTask(taskId).then((record) => {
-      if (record?.taskOverlay) orchestrator.applyOverlay(record.taskOverlay);
-    }).catch((err) => {
-      this.#deps.log({
-        event: "overlay_restore_failed",
-        taskId,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    });
     this.#deps.log({ event: "task_restored", taskId, channelId, initialState: opts.initialState });
   }
   async removeTask(taskId) {
@@ -92550,6 +92691,7 @@ var TaskManager = class {
       onAuthNotLoggedIn: () => this.#onAuthNotLoggedIn?.(),
       onRateLimitEvent: (info) => this.#onRateLimitEvent?.(info),
       sendControlMessage: this.#controlChannels.size > 0 ? this.#buildBroadcastFn() : void 0,
+      applyTaskSettings: (settings) => this.applyTaskSettings(taskId, settings),
       resourceRegistry: this.#deps.resourceRegistry,
       planRepo: this.#deps.planRepo,
       annotationStore: this.#deps.annotationStore,
@@ -92594,10 +92736,19 @@ var TaskManager = class {
       },
       onForwardedAck: (correlationId) => {
         this.#forwardedAckEmitters.get(taskId)?.(correlationId);
-      }
+      },
+      restoreInProgress: opts?.restoreInProgress ?? false
     });
   }
 };
+function applyPersistedComposerSettings(orchestrator, settings) {
+  const patch = {};
+  if (settings.model != null) patch.model = settings.model;
+  if (settings.reasoningEffort != null) patch.reasoningEffort = settings.reasoningEffort;
+  if (settings.permissionMode != null) patch.permissionMode = settings.permissionMode;
+  if (settings.fastMode != null) patch.fastMode = settings.fastMode;
+  if (Object.keys(patch).length > 0) orchestrator.applySettings(patch);
+}
 
 // src/services/task/manager/task-state-store.ts
 import { join as join45 } from "path";
@@ -95464,6 +95615,13 @@ function filterOutboundForCollab(msg, collabTaskId) {
     /** Explicitly filtered: pr_state nests taskId inside `data` */
     case "pr_state":
       return msg.data.taskId === collabTaskId ? msg : null;
+    /**
+     * settings_ack: task-scoped variant reaches collab peers if the task
+     * matches; daemon-wide variant (no taskId) is host-only.
+     */
+    case "settings_ack":
+      if (msg.taskId === void 0) return null;
+      return msg.taskId === collabTaskId ? msg : null;
     /** Suppressed: host-only settings and schedules */
     case "user_settings_snapshot":
     case "user_settings_updated":
@@ -95485,7 +95643,6 @@ function filterOutboundForCollab(msg, collabTaskId) {
     /** Suppressed: daemon-scoped messages with no taskId */
     case "capabilities":
     case "rate_limit_info":
-    case "settings_ack":
     case "enhance_prompt_chunk":
     case "mcp_server_auth_url":
     case "mcp_server_status":
@@ -96706,7 +96863,7 @@ function friendlyExecError(err) {
 async function refreshPluginCapabilities(daemon, tokenStore) {
   const [updatedMarketplace, updatedMcp, updatedSkills] = await Promise.all([
     detectMarketplacePlugins(),
-    import("./mcp-servers-XWOPKJ6F.js").then(
+    import("./mcp-servers-MUVTAMDT.js").then(
       (m2) => m2.detectMCPServers(daemon.capabilities.environments, tokenStore)
     ),
     import("./skills-NCKYNLUS.js").then(
@@ -97706,7 +97863,6 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
         }
         if (Object.keys(applied).length === 0) return;
         daemon.taskManager.applyTaskSettings(taskId, applied);
-        handler.sendControl({ type: "settings_ack", settings: applied, taskId });
         logAdapter({ event: "task_settings_updated", taskId, settings: applied });
       },
       onRequestCapabilities: () => {
@@ -98660,13 +98816,21 @@ function handleParticipantLeft(room, userId, deps) {
 }
 function handleWebrtcSignaling(room, type, targetUserId, payload, deps) {
   const peerId = namespacePeerId(room.roomId, targetUserId);
+  const generationId = `collab:${peerId}`;
+  deps.log({
+    event: "collab_generationid_placeholder",
+    roomId: room.roomId,
+    targetUserId,
+    type,
+    generationId
+  });
   const actions = {
     // eslint-disable-next-line no-restricted-syntax -- SDP is opaque z.unknown() from signaling
-    offer: () => room.peerManager.handleOffer(peerId, payload),
+    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),
+    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)
+    ice: () => room.peerManager.handleIce(peerId, payload, generationId)
   };
   actions[type]().catch((err) => {
     deps.log({ event: `collab_${type}_failed`, roomId: room.roomId, error: String(err) });
@@ -98810,6 +98974,7 @@ function createCollabRoomManager(deps) {
       const delayMs = expiresAt - Date.now();
       if (delayMs <= 0 || !Number.isFinite(delayMs)) {
         deps.log({ event: "collab_expired", roomId, expiresAt });
+        peerManager.destroy();
         collabRepoHandle.destroy().catch((err) => {
           deps.log({
             event: "collab_repo_destroy_failed",
@@ -100432,14 +100597,132 @@ function createPeerManager(config2) {
     }
     return factoryPromise;
   }
-  function tearDownPeer(machineId) {
+  async function resolveLiveEntry(fromMachineId, messageType, generationId) {
+    const direct = peers.get(fromMachineId);
+    if (direct) return direct;
+    const pending = pendingCreates.get(fromMachineId);
+    if (!pending) {
+      if (messageType === "answer") {
+        config2.log.warn({ fromMachineId, generationId }, "Received answer for unknown peer");
+      } else {
+        config2.log.debug(
+          { fromMachineId, generationId },
+          "Received ICE candidate for unknown peer"
+        );
+      }
+      return null;
+    }
+    let resolved;
+    try {
+      resolved = await pending;
+    } catch {
+      return null;
+    }
+    if (peers.get(fromMachineId) !== resolved) return null;
+    return resolved;
+  }
+  function discardSupersededPc(pc, event, fields) {
+    pc.onconnectionstatechange = null;
+    pc.onicecandidate = null;
+    pc.ondatachannel = null;
+    pc.close();
+    config2.logAdapter?.({ event, ...fields });
+  }
+  function abortInitiatorCreate(pc, targetMachineId) {
+    pendingCreates.delete(targetMachineId);
+    peers.delete(targetMachineId);
+    pc.onconnectionstatechange = null;
+    pc.onicecandidate = null;
+    pc.ondatachannel = null;
+    pc.close();
+  }
+  function setupInitiatorDataChannel(pc, targetMachineId, myGenerationId) {
+    if (!pc.createDataChannel) {
+      throw new Error("PeerConnection does not support createDataChannel");
+    }
+    let channel;
+    try {
+      channel = pc.createDataChannel(LORO_SYNC_LABEL, { ordered: true });
+    } catch (err) {
+      config2.log.warn(
+        { targetMachineId, err: String(err) },
+        "createDataChannel failed (connection likely closing)"
+      );
+      abortInitiatorCreate(pc, targetMachineId);
+      throw err;
+    }
+    const rawChannel = channel;
+    const peerId = machineIdToPeerId(targetMachineId);
+    const logAdapter = config2.logAdapter ?? noopLogAdapter;
+    const guarded = installLoroGuard(
+      rawChannel,
+      config2.webrtcAdapter,
+      peerId,
+      config2.log,
+      logAdapter
+    );
+    if (guarded) {
+      disposeLoroGuard(peerId);
+      loroGuards.set(peerId, guarded);
+    }
+    installInitiatorOnOpen(
+      rawChannel,
+      channel,
+      targetMachineId,
+      peerId,
+      myGenerationId,
+      logAdapter
+    );
+  }
+  function installInitiatorOnOpen(rawChannel, channel, targetMachineId, peerId, myGenerationId, logAdapter) {
+    rawChannel.onopen = () => {
+      const attachResult = safeAttachDataChannel(
+        () => {
+          config2.webrtcAdapter.attachDataChannel(
+            peerId,
+            // eslint-disable-next-line no-restricted-syntax -- RTCDataChannel from node-datachannel satisfies the adapter interface
+            channel
+          );
+        },
+        {
+          log: (entry) => logAdapter({ ...entry, peerId: String(peerId) }),
+          onStopped: () => {
+            const currentEntry = peers.get(targetMachineId);
+            if (currentEntry?.generationId !== myGenerationId) return;
+            config2.log.warn(
+              { targetMachineId, peerId: String(peerId) },
+              "Loro adapter in stopped state (initiator onopen); tearing down peer"
+            );
+            tearDownPeer(targetMachineId, "loro_adapter_stopped");
+          }
+        }
+      );
+      if (!attachResult.ok && attachResult.reason === "other") {
+        config2.log.warn(
+          { targetMachineId, err: String(attachResult.error) },
+          "attachDataChannel failed with non-stopped error"
+        );
+      }
+    };
+  }
+  function tearDownPeer(machineId, reason) {
     const peerId = machineIdToPeerId(machineId);
     disposeLoroGuard(peerId);
     config2.webrtcAdapter.detachDataChannel(peerId);
-    const pc = peers.get(machineId);
-    if (pc) {
-      pc.onconnectionstatechange = null;
-      pc.close();
+    const entry = peers.get(machineId);
+    if (entry) {
+      config2.logAdapter?.({
+        event: "peer_tear_down",
+        machineId,
+        generationId: entry.generationId,
+        ageMs: Date.now() - entry.createdAt,
+        lastState: entry.lastState,
+        reason: reason ?? "explicit"
+      });
+      entry.pc.onconnectionstatechange = null;
+      entry.pc.onicecandidate = null;
+      entry.pc.ondatachannel = null;
+      entry.pc.close();
       peers.delete(machineId);
     }
   }
@@ -100455,6 +100738,7 @@ function createPeerManager(config2) {
       logAdapter
     );
     if (guarded) {
+      disposeLoroGuard(peerId);
       loroGuards.set(peerId, guarded);
     }
     const attachResult = safeAttachDataChannel(
@@ -100472,7 +100756,7 @@ function createPeerManager(config2) {
             { machineId, peerId: String(peerId) },
             "Loro adapter in stopped state; tearing down peer"
           );
-          tearDownPeer(machineId);
+          tearDownPeer(machineId, "loro_adapter_stopped");
         }
       }
     );
@@ -100481,7 +100765,7 @@ function createPeerManager(config2) {
         { machineId, peerId: String(peerId), err: String(attachResult.error) },
         "attachDataChannel failed with non-stopped error; tearing down peer"
       );
-      tearDownPeer(machineId);
+      tearDownPeer(machineId, "attach_failed");
     }
   }
   function handleDataChannel(machineId, event) {
@@ -100578,181 +100862,277 @@ function createPeerManager(config2) {
       );
     }
   }
-  function setupPeerHandlers(machineId, pc) {
+  function setupPeerHandlers(machineId, pc, generationId) {
     pc.onicecandidate = (event) => {
       if (event.candidate) {
-        config2.onIceCandidate(machineId, {
-          candidate: event.candidate.candidate,
-          sdpMid: event.candidate.sdpMid,
-          sdpMLineIndex: event.candidate.sdpMLineIndex
-        });
+        config2.onIceCandidate(
+          machineId,
+          {
+            candidate: event.candidate.candidate,
+            sdpMid: event.candidate.sdpMid,
+            sdpMLineIndex: event.candidate.sdpMLineIndex
+          },
+          generationId
+        );
       }
     };
     pc.ondatachannel = (event) => {
       handleDataChannel(machineId, event);
     };
     pc.onconnectionstatechange = () => {
-      const state = pc.connectionState;
-      config2.log.info({ machineId, state }, "Peer connection state changed");
-      if (state === "failed" || state === "closed") {
-        tearDownPeer(machineId);
+      const currentEntry = peers.get(machineId);
+      if (currentEntry?.generationId !== generationId) {
+        config2.logAdapter?.({
+          event: "stale_state_change_ignored",
+          machineId,
+          staleGenerationId: generationId,
+          currentGenerationId: currentEntry?.generationId
+        });
+        return;
+      }
+      const newState = pc.connectionState;
+      const prevState = currentEntry.lastState;
+      const durationMs = Date.now() - currentEntry.lastStateAt;
+      config2.logAdapter?.({
+        event: "webrtc_state_transition",
+        machineId,
+        generationId,
+        prevState,
+        newState,
+        durationMs
+      });
+      config2.log.info(
+        { machineId, generationId, prevState, newState },
+        "Peer connection state changed"
+      );
+      currentEntry.lastState = newState;
+      currentEntry.lastStateAt = Date.now();
+      if (newState === "failed" || newState === "closed") {
+        tearDownPeer(machineId, newState);
       }
     };
   }
   return {
-    async handleOffer(fromMachineId, offer) {
-      config2.log.info({ fromMachineId }, "Handling WebRTC offer");
+    async handleOffer(fromMachineId, offer, generationId) {
       const existing = peers.get(fromMachineId);
-      if (existing) {
-        config2.log.debug({ fromMachineId }, "Closing existing peer connection");
-        tearDownPeer(fromMachineId);
-      }
-      const promise = (async () => {
-        const factory = await getFactory();
-        const pc = factory();
-        setupPeerHandlers(fromMachineId, pc);
-        await pc.setRemoteDescription(offer);
-        const answer = await pc.createAnswer();
-        await pc.setLocalDescription(answer);
-        peers.set(fromMachineId, pc);
-        pendingCreates.delete(fromMachineId);
-        config2.onAnswer(fromMachineId, { type: "answer", sdp: answer.sdp });
-        return pc;
+      config2.log.info(
+        {
+          fromMachineId,
+          generationId,
+          hadExistingPeer: !!existing,
+          priorGenerationId: existing?.generationId
+        },
+        "Handling WebRTC offer"
+      );
+      config2.logAdapter?.({
+        event: "webrtc_offer_received",
+        generationId,
+        fromMachineId,
+        hadExistingPeer: !!existing,
+        priorGenerationId: existing?.generationId
+      });
+      const inflight = pendingCreates.get(fromMachineId);
+      if (inflight) {
+        await Promise.race([
+          inflight.catch(() => void 0),
+          new Promise((resolve4) => setTimeout(resolve4, 500))
+        ]);
+      }
+      if (existing || peers.has(fromMachineId)) {
+        config2.log.debug({ fromMachineId, generationId }, "Closing existing peer connection");
+        tearDownPeer(fromMachineId, "replaced_by_offer");
+      }
+      const now = Date.now();
+      let promise;
+      promise = (async () => {
+        try {
+          const factory = await getFactory();
+          const pc = factory();
+          setupPeerHandlers(fromMachineId, pc, generationId);
+          await pc.setRemoteDescription(offer);
+          const answer = await pc.createAnswer();
+          await pc.setLocalDescription(answer);
+          const entry = {
+            pc,
+            generationId,
+            createdAt: now,
+            lastState: "new",
+            lastStateAt: now
+          };
+          if (pendingCreates.get(fromMachineId) !== promise) {
+            discardSupersededPc(pc, "webrtc_offer_superseded", { fromMachineId, generationId });
+            return entry;
+          }
+          peers.set(fromMachineId, entry);
+          pendingCreates.delete(fromMachineId);
+          config2.onAnswer(fromMachineId, { type: "answer", sdp: answer.sdp }, generationId);
+          return entry;
+        } catch (err) {
+          if (pendingCreates.get(fromMachineId) === promise) {
+            pendingCreates.delete(fromMachineId);
+          }
+          config2.logAdapter?.({
+            event: "webrtc_offer_handshake_failed",
+            fromMachineId,
+            generationId,
+            err: String(err)
+          });
+          throw err;
+        }
       })();
       pendingCreates.set(fromMachineId, promise);
       setTimeout(() => {
         if (pendingCreates.get(fromMachineId) === promise) {
           pendingCreates.delete(fromMachineId);
-          config2.log.warn({ fromMachineId }, "WebRTC handshake timed out");
+          config2.logAdapter?.({
+            event: "webrtc_handshake_timeout",
+            machineId: fromMachineId,
+            generationId
+          });
+          config2.log.warn({ fromMachineId, generationId }, "WebRTC handshake timed out");
         }
       }, HANDSHAKE_TIMEOUT_MS);
       await promise;
     },
     async initiateOffer(targetMachineId) {
-      config2.log.info({ targetMachineId }, "Initiating WebRTC offer");
+      const generationId = crypto.randomUUID();
+      config2.log.info({ targetMachineId, generationId }, "Initiating WebRTC offer");
       const existing = peers.get(targetMachineId);
       if (existing) {
-        tearDownPeer(targetMachineId);
+        tearDownPeer(targetMachineId, "replaced_by_initiate");
       }
-      const promise = (async () => {
-        const factory = await getFactory();
-        const pc = factory();
-        setupPeerHandlers(targetMachineId, pc);
-        if (!pc.createDataChannel) {
-          throw new Error("PeerConnection does not support createDataChannel");
-        }
-        if (!pc.createOffer) {
-          throw new Error("PeerConnection does not support createOffer");
-        }
-        let channel;
+      const now = Date.now();
+      let promise;
+      promise = (async () => {
         try {
-          channel = pc.createDataChannel(LORO_SYNC_LABEL, { ordered: true });
-        } catch (err) {
-          config2.log.warn(
-            { targetMachineId, err: String(err) },
-            "createDataChannel failed (connection likely closing)"
-          );
+          const factory = await getFactory();
+          const pc = factory();
+          setupPeerHandlers(targetMachineId, pc, generationId);
+          if (!pc.createOffer) {
+            throw new Error("PeerConnection does not support createOffer");
+          }
+          setupInitiatorDataChannel(pc, targetMachineId, generationId);
+          const offer = await pc.createOffer();
+          await pc.setLocalDescription(offer);
+          const entry = {
+            pc,
+            generationId,
+            createdAt: now,
+            lastState: "new",
+            lastStateAt: now
+          };
+          if (pendingCreates.get(targetMachineId) !== promise) {
+            disposeLoroGuard(machineIdToPeerId(targetMachineId));
+            discardSupersededPc(pc, "webrtc_initiate_superseded", {
+              targetMachineId,
+              generationId
+            });
+            return entry;
+          }
+          peers.set(targetMachineId, entry);
           pendingCreates.delete(targetMachineId);
-          peers.delete(targetMachineId);
-          pc.onconnectionstatechange = null;
-          pc.close();
+          config2.onOffer?.(targetMachineId, { type: "offer", sdp: offer.sdp }, generationId);
+          return entry;
+        } catch (err) {
+          if (pendingCreates.get(targetMachineId) === promise) {
+            pendingCreates.delete(targetMachineId);
+          }
+          config2.logAdapter?.({
+            event: "webrtc_initiate_handshake_failed",
+            targetMachineId,
+            generationId,
+            err: String(err)
+          });
           throw err;
         }
-        const rawChannel = channel;
-        const peerId = machineIdToPeerId(targetMachineId);
-        const logAdapter = config2.logAdapter ?? noopLogAdapter;
-        const guarded = installLoroGuard(
-          rawChannel,
-          config2.webrtcAdapter,
-          peerId,
-          config2.log,
-          logAdapter
-        );
-        if (guarded) {
-          loroGuards.set(peerId, guarded);
-        }
-        const myPc = pc;
-        rawChannel.onopen = () => {
-          const attachResult = safeAttachDataChannel(
-            () => {
-              config2.webrtcAdapter.attachDataChannel(
-                peerId,
-                // eslint-disable-next-line no-restricted-syntax -- RTCDataChannel from node-datachannel satisfies the adapter interface
-                channel
-              );
-            },
-            {
-              log: (entry) => logAdapter({ ...entry, peerId: String(peerId) }),
-              onStopped: () => {
-                const existingPc = peers.get(targetMachineId);
-                if (existingPc !== myPc) return;
-                config2.log.warn(
-                  { targetMachineId, peerId: String(peerId) },
-                  "Loro adapter in stopped state (initiator onopen); tearing down peer"
-                );
-                tearDownPeer(targetMachineId);
-              }
-            }
-          );
-          if (!attachResult.ok && attachResult.reason === "other") {
-            config2.log.warn(
-              { targetMachineId, err: String(attachResult.error) },
-              "attachDataChannel failed with non-stopped error"
-            );
-          }
-        };
-        const offer = await pc.createOffer();
-        await pc.setLocalDescription(offer);
-        peers.set(targetMachineId, pc);
-        pendingCreates.delete(targetMachineId);
-        config2.onOffer?.(targetMachineId, { type: "offer", sdp: offer.sdp });
-        return pc;
       })();
       pendingCreates.set(targetMachineId, promise);
       setTimeout(() => {
         if (pendingCreates.get(targetMachineId) === promise) {
           pendingCreates.delete(targetMachineId);
-          config2.log.warn({ targetMachineId }, "WebRTC handshake timed out (initiator)");
+          config2.logAdapter?.({
+            event: "webrtc_handshake_timeout",
+            machineId: targetMachineId,
+            generationId
+          });
+          config2.log.warn(
+            { targetMachineId, generationId },
+            "WebRTC handshake timed out (initiator)"
+          );
         }
       }, HANDSHAKE_TIMEOUT_MS);
       await promise;
     },
-    async handleAnswer(fromMachineId, answer) {
-      let pc = peers.get(fromMachineId);
-      if (!pc) {
-        const pending = pendingCreates.get(fromMachineId);
-        if (pending) {
-          pc = await pending;
-        } else {
-          config2.log.warn({ fromMachineId }, "Received answer for unknown peer");
-          return;
-        }
+    async handleAnswer(fromMachineId, answer, generationId) {
+      const entry = await resolveLiveEntry(fromMachineId, "answer", generationId);
+      if (!entry) return;
+      if (entry.generationId !== generationId) {
+        config2.logAdapter?.({
+          event: "webrtc_answer_stale",
+          fromMachineId,
+          currentGenerationId: entry.generationId,
+          staleGenerationId: generationId
+        });
+        config2.log.debug(
+          {
+            fromMachineId,
+            currentGenerationId: entry.generationId,
+            staleGenerationId: generationId
+          },
+          "Dropping stale WebRTC answer"
+        );
+        return;
       }
-      await pc.setRemoteDescription(answer);
+      await entry.pc.setRemoteDescription(answer);
     },
-    async handleIce(fromMachineId, candidate) {
-      let pc = peers.get(fromMachineId);
-      if (!pc) {
-        const pending = pendingCreates.get(fromMachineId);
-        if (pending) {
-          pc = await pending;
-        } else {
-          config2.log.debug({ fromMachineId }, "Received ICE candidate for unknown peer");
-          return;
-        }
+    async handleIce(fromMachineId, candidate, generationId) {
+      const entry = await resolveLiveEntry(fromMachineId, "ice", generationId);
+      if (!entry) return;
+      if (entry.generationId !== generationId) {
+        config2.logAdapter?.({
+          event: "webrtc_ice_candidate_stale",
+          fromMachineId,
+          currentGenerationId: entry.generationId,
+          staleGenerationId: generationId
+        });
+        config2.log.debug(
+          {
+            fromMachineId,
+            currentGenerationId: entry.generationId,
+            staleGenerationId: generationId
+          },
+          "Dropping stale ICE candidate"
+        );
+        return;
+      }
+      try {
+        await entry.pc.addIceCandidate(candidate);
+      } catch (err) {
+        config2.logAdapter?.({
+          event: "webrtc_ice_apply_failed",
+          fromMachineId,
+          generationId,
+          err: String(err)
+        });
+        config2.log.warn(
+          { fromMachineId, generationId, err: String(err) },
+          "addIceCandidate failed"
+        );
       }
-      await pc.addIceCandidate(candidate);
     },
     updateIceServers(servers) {
       config2.iceServers = servers;
       factoryPromise = null;
     },
     closePeer(targetId) {
-      tearDownPeer(targetId);
+      tearDownPeer(targetId, "close_peer");
     },
     destroy() {
       for (const machineId of [...peers.keys()]) {
-        tearDownPeer(machineId);
+        tearDownPeer(machineId, "destroy");
+      }
+      for (const guard of loroGuards.values()) {
+        guard.dispose();
       }
       peers.clear();
       pendingCreates.clear();
@@ -102423,7 +102803,15 @@ function wireAutoOpenBrowser(connection, signalingClient, authToken, signalingUr
 var WARN_EVENTS = /* @__PURE__ */ new Set([
   "subprocess_force_killed",
   "file_watcher_events_dropped",
-  "mcp_server_toggle_failed"
+  "mcp_server_toggle_failed",
+  /**
+   * WebRTC transient failures that match the `_failed` heuristic but are
+   * expected during normal reconnect scenarios (stale/closed PCs, network
+   * flap). Classify as warn to avoid flooding error-level telemetry.
+   */
+  "webrtc_ice_apply_failed",
+  "webrtc_offer_handshake_failed",
+  "webrtc_initiate_handshake_failed"
 ]);
 var DEBUG_EVENTS = /* @__PURE__ */ new Set([
   "port_detection_poll",
@@ -102444,19 +102832,19 @@ function routeSignalingMessage(peerManager, signalingHandle, log) {
     switch (msg.type) {
       case "webrtc-offer":
         if (msg.fromMachineId)
-          peerManager?.handleOffer(msg.fromMachineId, toSDPDescription(msg.offer)).catch(
+          peerManager?.handleOffer(msg.fromMachineId, toSDPDescription(msg.offer), msg.generationId).catch(
             (err) => log.error({ event: "webrtc_offer_failed", error: String(err) })
           );
         break;
       case "webrtc-answer":
         if (msg.fromMachineId)
-          peerManager?.handleAnswer(msg.fromMachineId, toSDPDescription(msg.answer)).catch(
+          peerManager?.handleAnswer(msg.fromMachineId, toSDPDescription(msg.answer), msg.generationId).catch(
             (err) => log.error({ event: "webrtc_answer_failed", error: String(err) })
           );
         break;
       case "webrtc-ice":
         if (msg.fromMachineId)
-          peerManager?.handleIce(msg.fromMachineId, toICECandidate(msg.candidate)).catch((err) => log.error({ event: "webrtc_ice_failed", error: String(err) }));
+          peerManager?.handleIce(msg.fromMachineId, toICECandidate(msg.candidate), msg.generationId).catch((err) => log.error({ event: "webrtc_ice_failed", error: String(err) }));
         break;
       case "ice-servers":
         peerManager?.updateIceServers(msg.iceServers);
@@ -102478,10 +102866,8 @@ function routeSignalingMessage(peerManager, signalingHandle, log) {
       case "error":
       case "authenticated":
         break;
-      default: {
-        const _exhaustive = msg;
-        void _exhaustive;
-      }
+      default:
+        assertNever(msg);
     }
   };
 }
@@ -102633,18 +103019,20 @@ function buildPeerManager(deps) {
   return createPeerManager({
     webrtcAdapter: personalWebrtcAdapter,
     logAdapter,
-    onAnswer: (targetMachineId, answer) => {
+    onAnswer: (targetMachineId, answer, generationId) => {
       signalingHandle.connection.send({
         type: "webrtc-answer",
         targetMachineId,
-        answer
+        answer,
+        generationId
       });
     },
-    onIceCandidate: (targetMachineId, candidate) => {
+    onIceCandidate: (targetMachineId, candidate, generationId) => {
       signalingHandle.connection.send({
         type: "webrtc-ice",
         targetMachineId,
-        candidate
+        candidate,
+        generationId
       });
     },
     onPeerDataChannel: (machineId) => {
@@ -103304,4 +103692,4 @@ export {
   _testing,
   serve
 };
-//# sourceMappingURL=serve-P5WC5JIT.js.map
+//# sourceMappingURL=serve-X4R5CDHD.js.map