@schoolai/shipyard 3.1.1 → 3.2.0-rc.20260416.0

package/dist/{serve-HDRZ2CU6.js → serve-ZD5RISIM.js}

@@ -37,7 +37,7 @@ import {
   VaultKeyPutRequestSchema,
   VaultKeyPutResponseSchema,
   classifyClaudeCodeCompatibility
-} from "./chunk-ERKQ6CBC.js";
+} from "./chunk-2RV2XXAI.js";
 import {
   loadAuthToken
 } from "./chunk-IHSXN66C.js";
@@ -24345,7 +24345,8 @@ var DiffHunkAnnotationSchema = BaseCommentZodSchema.extend({
   lineNumber: external_exports.number(),
   lineContent: external_exports.string(),
   lineContentHash: external_exports.string(),
-  side: external_exports.enum(["original", "modified"])
+  side: external_exports.enum(["original", "modified"]),
+  diffScope: external_exports.enum(["working-tree", "branch", "last-turn", "pr"]).optional()
 });
 var PreviewElementAnnotationSchema = BaseCommentZodSchema.extend({
   annotationType: external_exports.literal("preview-element"),
@@ -24590,6 +24591,7 @@ var CrdtCompactor = class {
 };
 var PLAN_EPOCH = 3;
 var CANVAS_EPOCH = 2;
+var OBSOLETE_PREFIXES = /* @__PURE__ */ new Set(["typing", "task-view"]);
 var DOCUMENT_PREFIXES = ["plan", "canvas"];
 var PREFIX_SET = new Set(DOCUMENT_PREFIXES);
 function isDocumentPrefix(value) {
@@ -26709,6 +26711,17 @@ var BrowserToFileIOMessageSchema = external_exports.discriminatedUnion("type", [
   external_exports.object({
     type: external_exports.literal("git_ls_files"),
     requestId: external_exports.string()
+  }),
+  external_exports.object({
+    type: external_exports.literal("git_branch_diff_files"),
+    requestId: external_exports.string(),
+    baseRef: external_exports.string().optional()
+  }),
+  external_exports.object({
+    type: external_exports.literal("git_branch_diff_file"),
+    requestId: external_exports.string(),
+    path: external_exports.string(),
+    mergeBase: external_exports.string()
   })
 ]);
 var FileChangeSchema = external_exports.object({
@@ -26770,6 +26783,19 @@ var DaemonToFileIOMessageSchema = external_exports.discriminatedUnion("type", [
     requestId: external_exports.string(),
     files: external_exports.array(external_exports.string())
   }),
+  external_exports.object({
+    type: external_exports.literal("git_branch_diff_files_result"),
+    requestId: external_exports.string(),
+    files: external_exports.array(CheckpointFileEntrySchema),
+    mergeBase: external_exports.string(),
+    baseRef: external_exports.string()
+  }),
+  external_exports.object({
+    type: external_exports.literal("git_branch_diff_file_result"),
+    requestId: external_exports.string(),
+    originalContent: external_exports.string(),
+    modifiedContent: external_exports.string()
+  }),
   external_exports.object({ type: external_exports.literal("error"), requestId: external_exports.string(), error: external_exports.string() }),
   external_exports.object({
     type: external_exports.literal("checkpoint_ready"),
@@ -28754,6 +28780,35 @@ async function rerunChecks(cwd, prNumber) {
   }
 }
 
+// src/shared/capabilities/git-diff.ts
+async function getDefaultBranch(cwd) {
+  try {
+    const ref = await runWithTimeout(
+      "git",
+      ["symbolic-ref", "refs/remotes/origin/HEAD", "--short"],
+      cwd,
+      TIMEOUT_MS
+    );
+    return ref || null;
+  } catch {
+  }
+  for (const candidate of ["origin/main", "origin/master"]) {
+    try {
+      await runWithTimeout("git", ["rev-parse", "--verify", candidate], cwd, TIMEOUT_MS);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+async function getMergeBase(cwd, baseBranch) {
+  try {
+    return await runWithTimeout("git", ["merge-base", baseBranch, "HEAD"], cwd, TIMEOUT_MS);
+  } catch {
+    return null;
+  }
+}
+
 // src/shared/capabilities/index.ts
 var AutoModeConfigSchema = external_exports.object({
   cachedGrowthBookFeatures: external_exports.object({ tengu_auto_mode_config: external_exports.object({ enabled: external_exports.string() }) }).passthrough()
@@ -29215,6 +29270,28 @@ function narrow(value) {
 import { unlinkSync } from "fs";
 import { readFile as readFile5, unlink as unlink2, writeFile as writeFile3 } from "fs/promises";
 import { join as join8 } from "path";
+
+// src/services/bootstrap/classify-uncaught-error.ts
+function classifyUncaughtError(error2) {
+  if (!(error2 instanceof Error)) return "fatal";
+  const code2 = "code" in error2 && typeof error2.code === "string" ? error2.code : void 0;
+  const msg = error2.message;
+  if (code2 === "EPIPE" || code2 === "ECONNRESET" || code2 === "ECONNABORTED" || code2 === "ECONNREFUSED" || code2 === "ERR_STREAM_DESTROYED") {
+    return "recoverable";
+  }
+  if (msg.includes("can't add channel") && msg.includes("stopped")) {
+    return "recoverable";
+  }
+  if (msg.includes("RTCDataChannel.readyState is not")) {
+    return "recoverable";
+  }
+  if (msg.includes("ProcessTransport is not ready")) {
+    return "recoverable";
+  }
+  return "fatal";
+}
+
+// src/services/bootstrap/lifecycle.ts
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -29244,7 +29321,12 @@ var LifecycleManager = class {
     process.on("SIGTERM", termHandler);
     process.on("SIGINT", intHandler);
     const exceptionHandler = (error2) => {
-      this.#log.error({ err: error2 }, "Uncaught exception \u2014 initiating shutdown");
+      const severity = classifyUncaughtError(error2);
+      if (severity === "recoverable") {
+        this.#log.warn({ err: error2 }, "Recoverable uncaught exception \u2014 absorbed");
+        return;
+      }
+      this.#log.error({ err: error2 }, "Fatal uncaught exception \u2014 initiating shutdown");
       void this.#shutdown("uncaughtException");
     };
     const rejectionHandler = (reason) => {
@@ -29588,7 +29670,7 @@ function nanoid(size2 = 21) {
 }
 
 // src/services/bootstrap/signaling.ts
-var DAEMON_NPM_VERSION = true ? "3.1.1" : "unknown";
+var DAEMON_NPM_VERSION = true ? "3.2.0" : "unknown";
 function createDaemonSignaling(config2) {
   const agentId = config2.agentId ?? nanoid();
   function send(msg) {
@@ -29743,6 +29825,7 @@ function handleBrowserPreviewChannel(port, send, sendBinary, log, options) {
   const requestTimeoutMs = options?.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
   const activeRequests = /* @__PURE__ */ new Map();
   const cookieJar = /* @__PURE__ */ new Map();
+  const previewPrefix = `/__preview/url/${encodeURIComponent(`http://localhost:${port}`)}/`;
   function respond(msg) {
     send(JSON.stringify(msg));
   }
@@ -29896,7 +29979,7 @@ function handleBrowserPreviewChannel(port, send, sendBinary, log, options) {
     res.on("data", (chunk) => chunks.push(chunk));
     res.on("end", () => {
       const rawJs = Buffer.concat(chunks).toString("utf-8");
-      const rewritten = rewriteJsImportPaths(rawJs);
+      const rewritten = rewriteJsImportPaths(rawJs, previewPrefix);
       const body = new TextEncoder().encode(rewritten);
       headers["content-length"] = String(body.byteLength);
       respond({
@@ -30019,8 +30102,9 @@ function injectBaseHref(html, origin) {
 function rewriteRootRelativePaths(html) {
   return html.replace(/((?:src|href|action)\s*=\s*["'])\/(?!\/)/gi, "$1./");
 }
-function rewriteJsImportPaths(js) {
-  return js.replace(/((?:from|import)\s*\(\s*["'])\/(?!\/)/g, "$1./").replace(/(from\s+["'])\/(?!\/)/g, "$1./");
+function rewriteJsImportPaths(js, previewPrefix) {
+  const replacement = previewPrefix ?? "./";
+  return js.replace(/((?:from|import)\s*\(\s*["'])\/(?!\/)/g, `$1${replacement}`).replace(/(from\s+["'])\/(?!\/)/g, `$1${replacement}`);
 }
 function handleBrowserPreviewUrlChannel(send, sendBinary, log, options) {
   const requestTimeoutMs = options?.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
@@ -30113,7 +30197,10 @@ function handleBrowserPreviewUrlChannel(send, sendBinary, log, options) {
         injectBaseHref(new TextDecoder().decode(rawBody), targetUrl.origin)
       );
     } else if (isJs) {
-      body = new TextEncoder().encode(rewriteJsImportPaths(new TextDecoder().decode(rawBody)));
+      const urlPrefix = `/__preview/url/${encodeURIComponent(targetUrl.origin)}/`;
+      body = new TextEncoder().encode(
+        rewriteJsImportPaths(new TextDecoder().decode(rawBody), urlPrefix)
+      );
     } else {
       body = rawBody;
     }
@@ -32301,8 +32388,7 @@ async function sweepStaleTasks(taskStateStore, taskManager, log) {
   const noBroadcast = { broadcast: false };
   for (const action of actions) {
     if (action.kind === "mark_input_required") {
-      await taskStateStore.updateTaskStatus(action.taskId, "input_required", noBroadcast);
-      await taskStateStore.acknowledge(action.taskId, noBroadcast);
+      await taskStateStore.sweepToInputRequired(action.taskId, noBroadcast);
       log({
         event: "stale_task_swept",
         taskId: action.taskId,
@@ -43227,6 +43313,11 @@ Use \`add_comment\` to annotate your work and respond to reviewer feedback. Use
 
 You can **create** comments on diff and plan surfaces only (\`mode: "diff"\` and \`mode: "plan"\`). You can **reply** to comments on all 5 surfaces. Preview and canvas comments are user-originated feedback on your running app or visualizations \u2014 respond by replying to acknowledge and acting on the feedback.
 
+**Diff scope** \u2014 \`diff\` surface comments may include a \`diff-scope\` attribute indicating which view the comment was made on:
+- \`working-tree\` \u2014 uncommitted changes (your latest edits, like \`git diff\`)
+- \`branch\` \u2014 full branch diff vs base branch (all commits + uncommitted, like \`git diff main...HEAD\`)
+- \`last-turn\` \u2014 changes from a specific agent turn
+
 **When publishing plans** \u2014 \`mode: "plan"\` for non-obvious design decisions, anchored to specific plan text.
 
 **Periodically during long tasks** \u2014 \`list_comments\` to catch missed feedback, especially after context loss.
@@ -75126,8 +75217,10 @@ function deriveArtifact(annotation, taskId) {
 }
 function surfaceAttrs(annotation) {
   switch (annotation.annotationType) {
-    case "diff-hunk":
-      return ` file="${escapeXmlAttr(annotation.filePath)}" line="${annotation.lineNumber}"`;
+    case "diff-hunk": {
+      const scopeAttr = annotation.diffScope ? ` diff-scope="${escapeXmlAttr(annotation.diffScope)}"` : "";
+      return ` file="${escapeXmlAttr(annotation.filePath)}" line="${annotation.lineNumber}"${scopeAttr}`;
+    }
     case "plan-text":
       return annotation.anchorText ? ` anchor="${escapeXmlAttr(annotation.anchorText)}"` : "";
     case "preview-element":
@@ -76776,8 +76869,6 @@ ${conversationReplay}` : conversationReplay;
       });
       this.#ownSessionId = null;
       this.#effectiveSpawnMode = { kind: "fresh" };
-      this.#config.sessionPersistence.clear(this.#config.channelId).catch(() => {
-      });
     }
     if (this.#tryForkFailedRetry(error2)) return;
     if (this.#tryStaleResumeRetry(error2)) return;
@@ -79671,7 +79762,7 @@ var SideThreadRegistry = class {
           };
         },
         onSubprocessEvent: (event) => {
-          if (event.type === "turn_complete") {
+          if (event.type === "turn_complete" || event.type === "sdk_error" || event.type === "subprocess_died") {
             this.#deps.onThreadTurnComplete(params.threadId);
           }
         }
@@ -80354,7 +80445,7 @@ var StructuredTaskTracker = class {
    * 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) {
+  attachFileWatcher(sessionId, options) {
     if (this.#ccTaskWatcherDispose) {
       this.#deps.log({
         event: "file_watcher_already_attached",
@@ -80365,17 +80456,17 @@ var StructuredTaskTracker = class {
     }
     const watcher = createCCTaskFileWatcher(sessionId, this.#deps.log);
     this.#ccTaskFileWriter = createCCTaskFileWriter(watcher.dir, this.#deps.log);
-    this.#initFileWatcher(watcher);
+    this.#initFileWatcher(watcher, options);
     if (this.#currentOverlay) {
-      this.#flushStructuredTasks();
+      this.#flushStructuredTasks(options);
     }
   }
   /**
    * Apply an overlay on top of CC tasks. Stores the overlay and re-flushes.
    */
-  applyOverlay(overlay) {
+  applyOverlay(overlay, options) {
     this.#currentOverlay = overlay;
-    this.#flushStructuredTasks();
+    this.#flushStructuredTasks(options);
   }
   processStructuredTaskEvents(content) {
     const events = extractStructuredTaskEvents(content);
@@ -80500,11 +80591,11 @@ var StructuredTaskTracker = class {
     applyDepEdgeAdditions(merged, overlay.depEdges);
     return merged;
   }
-  #flushStructuredTasks() {
+  #flushStructuredTasks(options) {
     const overlay = this.#currentOverlay ?? DEFAULT_TASK_OVERLAY;
     const merged = this.#applyOverlayToMap(this.#structuredTasks, overlay);
     const todoProgress = this.#computeTodoProgress(merged);
-    this.#deps.updateStructuredTasks(Object.fromEntries(merged), todoProgress);
+    this.#deps.updateStructuredTasks(Object.fromEntries(merged), todoProgress, options);
     if (!this.#suppressWriteThrough) {
       this.#ccTaskFileWriter?.writeMergedTasks(merged);
     }
@@ -80525,9 +80616,12 @@ var StructuredTaskTracker = class {
       currentActivity
     };
   }
-  #initFileWatcher(watcher) {
+  #initFileWatcher(watcher, initOptions) {
+    let isFirstRead = !!initOptions?.preserveUpdatedAt;
     this.#ccTaskWatcherDispose = watcher.watch((tasks) => {
-      this.#reconcileFromDisk(tasks);
+      const opts = isFirstRead ? initOptions : void 0;
+      isFirstRead = false;
+      this.#reconcileFromDisk(tasks, opts);
     });
   }
   /**
@@ -80537,7 +80631,7 @@ var StructuredTaskTracker = class {
    * - Remove tasks that were previously from disk but are now gone
    * - Re-flush with overlay applied
    */
-  #reconcileFromDisk(ccTasks) {
+  #reconcileFromDisk(ccTasks, options) {
     const currentDiskIds = /* @__PURE__ */ new Set();
     for (const file of ccTasks) {
       currentDiskIds.add(file.id);
@@ -80558,7 +80652,7 @@ var StructuredTaskTracker = class {
     }
     this.#suppressWriteThrough = true;
     try {
-      this.#flushStructuredTasks();
+      this.#flushStructuredTasks(options);
     } finally {
       this.#suppressWriteThrough = false;
     }
@@ -81296,7 +81390,9 @@ var Task = class _Task {
       log: deps.log
     });
     if (deps.existingSessionId) {
-      this.#structuredTaskTracker.attachFileWatcher(deps.existingSessionId);
+      this.#structuredTaskTracker.attachFileWatcher(deps.existingSessionId, {
+        preserveUpdatedAt: true
+      });
     }
     this.#subagentManager = new SubagentManager({
       taskId: deps.taskId,
@@ -82424,6 +82520,8 @@ Use this context to maintain continuity. You have already done this work \u2014
     }
   }
   #handleSdkError(event) {
+    this.#collabQueue.onTurnComplete();
+    this.#pushManager.onTurnEnd();
     this.#deps.metricsCollector.capture("agent_error", {
       taskId: this.#deps.taskId,
       errorType: event.errorSubtype ?? "sdk_error",
@@ -82443,6 +82541,8 @@ Use this context to maintain continuity. You have already done this work \u2014
     }
   }
   #handleSubprocessDied() {
+    this.#collabQueue.onTurnComplete();
+    this.#pushManager.onTurnEnd();
     this.#mcpPoller.stop();
     if (this.#lastTurnResult != null) {
       this.#costBaseline = {
@@ -82524,8 +82624,8 @@ Use this context to maintain continuity. You have already done this work \u2014
       }
     }
   }
-  applyOverlay(overlay) {
-    this.#structuredTaskTracker.applyOverlay(overlay);
+  applyOverlay(overlay, options) {
+    this.#structuredTaskTracker.applyOverlay(overlay, options);
   }
   /** ---------------------------------------------------------------- */
   /** Resource resolution                                              */
@@ -83202,7 +83302,8 @@ var TaskManager = class {
     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);
+      if (record?.taskOverlay)
+        orchestrator.applyOverlay(record.taskOverlay, { preserveUpdatedAt: true });
     }).catch((err) => {
       this.#deps.log({
         event: "overlay_restore_failed",
@@ -83244,10 +83345,27 @@ var TaskManager = class {
   getTaskMode(taskId) {
     return this.#tasks.get(taskId)?.mode ?? "task";
   }
-  handleUserMessage(taskId, content, settings, cwd, participantId, senderDisplayName) {
-    const task = this.#tasks.get(taskId);
+  async handleUserMessage(taskId, content, settings, cwd, participantId, senderDisplayName) {
+    let task = this.#tasks.get(taskId);
     if (!task) {
-      throw new Error(`No orchestrator for task ${taskId}`);
+      const record = await this.#deps.taskStateStore.getTask(taskId);
+      if (!record) {
+        throw new Error(`No orchestrator for task ${taskId}`);
+      }
+      this.restoreOrchestrator(taskId, record.channelId, {
+        initialState: "cold_idle",
+        cwd: record.cwd,
+        mode: record.mode,
+        costBaseline: {
+          totalCostUsd: record.totalCostUsd,
+          totalOutputTokens: record.totalOutputTokens
+        }
+      });
+      task = this.#tasks.get(taskId);
+      if (!task) {
+        throw new Error(`Failed to restore orchestrator for task ${taskId}`);
+      }
+      this.#deps.log({ event: "task_lazy_restored", taskId, channelId: record.channelId });
     }
     if (cwd && cwd !== task.cwd) {
       task.cwd = cwd;
@@ -83567,8 +83685,13 @@ var TaskManager = class {
           });
         });
       },
-      updateStructuredTasks: (tasks, todoProgress) => {
-        this.#deps.taskStateStore.updateStructuredTasks(taskId, tasks, todoProgress).catch((err) => {
+      updateStructuredTasks: (tasks, todoProgress, options) => {
+        this.#deps.taskStateStore.updateStructuredTasks(
+          taskId,
+          tasks,
+          todoProgress,
+          options ? { preserveUpdatedAt: options.preserveUpdatedAt } : void 0
+        ).catch((err) => {
           this.#deps.log({
             event: "task_state_store_structured_tasks_failed",
             taskId,
@@ -83715,52 +83838,29 @@ function buildTaskStateStore(dataDir) {
       });
     },
     async updateTaskStatus(taskId, status, options) {
-      const task = await store.get(taskId);
-      if (!task) return;
-      pushBroadcast(options);
-      await store.set(taskId, applyStatusTransition(task, status, Date.now()));
+      await safeUpdate(taskId, (task) => applyStatusTransition(task, status, Date.now()), options);
     },
     async updateTitle(taskId, title, options) {
-      const task = await store.get(taskId);
-      if (!task) return;
-      pushBroadcast(options);
-      await store.set(taskId, {
-        ...task,
-        title,
-        updatedAt: Date.now()
-      });
+      await safeUpdate(taskId, (task) => ({ ...task, title, updatedAt: Date.now() }), options);
     },
     async updateCwd(taskId, cwd, options) {
-      const task = await store.get(taskId);
-      if (!task) return;
-      pushBroadcast(options);
-      await store.set(taskId, {
-        ...task,
-        cwd,
-        updatedAt: Date.now()
-      });
+      await safeUpdate(taskId, (task) => ({ ...task, cwd, updatedAt: Date.now() }), options);
     },
     async updateMode(taskId, mode, options) {
-      const task = await store.get(taskId);
-      if (!task) return;
-      pushBroadcast(options);
-      await store.set(taskId, {
-        ...task,
-        mode,
-        updatedAt: Date.now()
-      });
+      await safeUpdate(taskId, (task) => ({ ...task, mode, updatedAt: Date.now() }), options);
     },
     async updateTodoProgress(taskId, progress, options) {
-      const task = await store.get(taskId);
-      if (!task) return;
-      pushBroadcast(options);
-      await store.set(taskId, {
-        ...task,
-        todoCompleted: progress.todoCompleted,
-        todoTotal: progress.todoTotal,
-        currentActivity: progress.currentActivity,
-        updatedAt: Date.now()
-      });
+      await safeUpdate(
+        taskId,
+        (task) => ({
+          ...task,
+          todoCompleted: progress.todoCompleted,
+          todoTotal: progress.todoTotal,
+          currentActivity: progress.currentActivity,
+          updatedAt: Date.now()
+        }),
+        options
+      );
     },
     async acknowledge(taskId, options) {
       await safeUpdate(taskId, (task) => ({ ...task, acknowledgedAt: Date.now() }), options);
@@ -83769,39 +83869,42 @@ function buildTaskStateStore(dataDir) {
       await safeUpdate(taskId, (task) => ({ ...task, pinned: !task.pinned }), options);
     },
     async updateStructuredTasks(taskId, tasks, todoProgress, options) {
-      const task = await store.get(taskId);
-      if (!task) return;
-      pushBroadcast(options);
-      await store.set(taskId, {
-        ...task,
-        structuredTasks: tasks,
-        ...todoProgress && {
-          todoCompleted: todoProgress.todoCompleted,
-          todoTotal: todoProgress.todoTotal,
-          currentActivity: todoProgress.currentActivity
-        },
-        updatedAt: Date.now()
-      });
+      await safeUpdate(
+        taskId,
+        (task) => ({
+          ...task,
+          structuredTasks: tasks,
+          ...todoProgress && {
+            todoCompleted: todoProgress.todoCompleted,
+            todoTotal: todoProgress.todoTotal,
+            currentActivity: todoProgress.currentActivity
+          },
+          updatedAt: options?.preserveUpdatedAt ? task.updatedAt : Date.now()
+        }),
+        options
+      );
     },
     async updateTaskOverlay(taskId, overlay, options) {
-      const task = await store.get(taskId);
-      if (!task) return;
-      pushBroadcast(options);
-      await store.set(taskId, {
-        ...task,
-        taskOverlay: overlay,
-        updatedAt: Date.now()
-      });
+      await safeUpdate(
+        taskId,
+        (task) => ({
+          ...task,
+          taskOverlay: overlay,
+          updatedAt: options?.preserveUpdatedAt ? task.updatedAt : Date.now()
+        }),
+        options
+      );
     },
     async updateComposerSettings(taskId, settings, options) {
-      const task = await store.get(taskId);
-      if (!task) return;
-      pushBroadcast(options);
-      await store.set(taskId, {
-        ...task,
-        composerSettings: { ...task.composerSettings, ...settings },
-        updatedAt: Date.now()
-      });
+      await safeUpdate(
+        taskId,
+        (task) => ({
+          ...task,
+          composerSettings: { ...task.composerSettings, ...settings },
+          updatedAt: Date.now()
+        }),
+        options
+      );
     },
     async updateCostStats(taskId, stats, options) {
       await safeUpdate(
@@ -83827,12 +83930,27 @@ function buildTaskStateStore(dataDir) {
         options
       );
     },
+    async sweepToInputRequired(taskId, options) {
+      await safeUpdate(
+        taskId,
+        (task) => ({
+          ...task,
+          status: "input_required",
+          taskStartedAt: null
+        }),
+        options
+      );
+    },
     async getTask(taskId) {
       return store.get(taskId);
     },
     async listTasks() {
       return store.list();
     },
+    async listTasksWithVersion() {
+      const tasks = await store.list();
+      return { tasks, version: _version };
+    },
     subscribe(listener) {
       taskListeners.add(listener);
       return () => {
@@ -84145,13 +84263,15 @@ ${additionalSystemPrompt}` : basePrompt;
 async function detectInitialCapabilities(tokenStore, settings) {
   return detectCapabilities(tokenStore, settings.preferredAnthropicAuth ?? void 0);
 }
-function applyProxyFiltering(merged, proxyRef, proxyManagedNames, disabledNames) {
-  for (const name of proxyManagedNames) {
+function applyProxyFiltering(merged, proxyRef, disabledNames) {
+  const proxy = proxyRef.current;
+  if (!proxy) return;
+  for (const name of proxy.getAllManagedNames()) {
     if (name in merged) {
       delete merged[name];
     }
   }
-  const freshConfigs = proxyRef.current?.getServerConfigs() ?? /* @__PURE__ */ new Map();
+  const freshConfigs = proxy.getServerConfigs();
   for (const [name, config2] of freshConfigs) {
     if (!disabledNames.has(name)) {
       merged[name] = config2;
@@ -84180,7 +84300,7 @@ function collectProxyEndpoints(capabilitiesRef, claudeAiToken) {
   }
   return endpoints;
 }
-async function initializeProxyServer(deps, capabilitiesRef, proxyManagedNames, onReauthComplete) {
+async function initializeProxyServer(deps, capabilitiesRef, onReauthComplete) {
   const claudeAiToken = await readAnthropicOAuthToken();
   const proxyEndpoints = collectProxyEndpoints(capabilitiesRef, claudeAiToken ?? void 0);
   if (proxyEndpoints.size === 0) return { proxyServer: null };
@@ -84192,11 +84312,14 @@ async function initializeProxyServer(deps, capabilitiesRef, proxyManagedNames, o
   });
   try {
     await proxy.initialize(proxyEndpoints);
-    for (const name of proxyEndpoints.keys()) proxyManagedNames.add(name);
+    const connectedNames = proxy.getServerNames();
+    const allNames = [...proxyEndpoints.keys()];
     deps.log({
       event: "mcp_proxy_initialized",
       serverCount: proxyEndpoints.size,
-      serverNames: [...proxyEndpoints.keys()]
+      connectedCount: connectedNames.length,
+      connectedNames,
+      failedNames: allNames.filter((n) => !connectedNames.includes(n))
     });
     return { proxyServer: proxy };
   } catch (err) {
@@ -84409,7 +84532,6 @@ async function createDaemon(deps) {
       initialContent
     );
   }
-  const proxyManagedNames = /* @__PURE__ */ new Set();
   const resolveMcpServers = () => {
     if (isVanillaAgentMode()) return void 0;
     const userServers = resolveUserMcpServers(capabilitiesRef.current, deps.tokenStore);
@@ -84417,9 +84539,11 @@ async function createDaemon(deps) {
       capabilitiesRef.current?.mcpServers?.filter((s2) => !s2.enabled).map((s2) => s2.name) ?? []
     );
     const pluginServers = resolvePluginMcpServersMap(deps.tokenStore, deps.log, disabledNames);
-    if (!userServers && pluginServers.size === 0 && proxyManagedNames.size === 0) return void 0;
+    const proxyManagedNames = proxyRef.current?.getAllManagedNames() ?? [];
+    if (!userServers && pluginServers.size === 0 && proxyManagedNames.length === 0)
+      return void 0;
     const merged = mergePluginAndUserServers(pluginServers, userServers, deps.log);
-    applyProxyFiltering(merged, proxyRef, proxyManagedNames, disabledNames);
+    applyProxyFiltering(merged, proxyRef, disabledNames);
     deps.log({
       event: "resolve_mcp_servers",
       capabilityServerCount: capabilitiesRef.current?.mcpServers?.length ?? 0,
@@ -84427,7 +84551,7 @@ async function createDaemon(deps) {
       userServerCount: userServers ? Object.keys(userServers).length : 0,
       userServerNames: userServers ? Object.keys(userServers) : [],
       pluginServerCount: pluginServers.size,
-      proxyManaged: [...proxyManagedNames],
+      proxyManaged: proxyManagedNames,
       mergedCount: Object.keys(merged).length,
       mergedNames: Object.keys(merged)
     });
@@ -84493,7 +84617,13 @@ async function createDaemon(deps) {
       taskManager.createTask(params);
     },
     sendMessage: (taskId, content, settings, cwd) => {
-      taskManager.handleUserMessage(taskId, content, settings, cwd);
+      taskManager.handleUserMessage(taskId, content, settings, cwd).catch((err) => {
+        deps.log({
+          event: "schedule_send_message_error",
+          taskId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
     },
     getRunningScheduleIds: async () => {
       const running = /* @__PURE__ */ new Set();
@@ -84652,7 +84782,6 @@ async function createDaemon(deps) {
   const { proxyServer } = await initializeProxyServer(
     deps,
     capabilitiesRef,
-    proxyManagedNames,
     () => oauthStateStore.invalidate()
   );
   proxyRef.current = proxyServer;
@@ -87109,7 +87238,10 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
           if (resolved) {
             const without = { ...resolved };
             delete without[serverName];
-            daemon.preWarmManager.updateMcpServers(without).then(() => daemon.preWarmManager.updateMcpServers(resolved)).then(() => daemon.taskManager.triggerFastMcpPolling()).catch((err) => {
+            daemon.preWarmManager.updateMcpServers(without).then(() => daemon.preWarmManager.updateMcpServers(resolved)).then(() => {
+              daemon.taskManager.reconnectMcpServer(serverName);
+              daemon.taskManager.triggerFastMcpPolling();
+            }).catch((err) => {
               logAdapter({
                 event: `${eventName}_reconnect_failed`,
                 serverName,
@@ -87328,12 +87460,11 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
         });
       },
       onRequestTaskIndex: () => {
-        const snapshotVersion = daemon.taskStateStore.version;
-        daemon.taskStateStore.listTasks().then((tasks) => {
+        daemon.taskStateStore.listTasksWithVersion().then(({ tasks, version }) => {
           controlHandler.sendControl({
             type: "task_index_snapshot",
             tasks,
-            version: snapshotVersion
+            version
           });
         }).catch((err) => {
           logAdapter({
@@ -87547,19 +87678,6 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
     }
   };
   pushMcpStatus(5);
-  const initialSnapshotVersion = daemon.taskStateStore.version;
-  daemon.taskStateStore.listTasks().then((tasks) => {
-    controlHandler.sendControl({
-      type: "task_index_snapshot",
-      tasks,
-      version: initialSnapshotVersion
-    });
-  }).catch((err) => {
-    logAdapter({
-      event: "task_index_initial_push_failed",
-      error: err instanceof Error ? err.message : String(err)
-    });
-  });
   daemon.userSettingsStore.getSettings().then((settings) => {
     controlHandler.sendControl({ type: "user_settings_snapshot", settings });
   }).catch((err) => {
@@ -87661,7 +87779,7 @@ function handleMessageChannel(opts) {
     }
     return result.data;
   }
-  function handleSendMessage2(msg) {
+  async function handleSendMessage2(msg) {
     try {
       const settings = {
         model: msg.model,
@@ -87672,7 +87790,7 @@ function handleMessageChannel(opts) {
       if (opts.onUserMessage) {
         opts.onUserMessage(msg.content, settings, msg.cwd, participantId, senderDisplayName);
       } else {
-        taskManager.handleUserMessage(
+        await taskManager.handleUserMessage(
           taskId,
           msg.content,
           settings,
@@ -87755,7 +87873,7 @@ function handleMessageChannel(opts) {
     }
     switch (msg.type) {
       case "send_message":
-        handleSendMessage2(msg);
+        void handleSendMessage2(msg);
         break;
       case "stop":
         if (opts.onStop) opts.onStop();
@@ -88186,7 +88304,9 @@ function buildCollabPermissions(registry) {
   return {
     visibility: isAllowed,
     mutability: isAllowed,
-    creation(_docId, peer) {
+    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);
@@ -88259,15 +88379,15 @@ var LEGACY_PREFIXES = [
   "diff-review",
   "preview-annotation"
 ];
-var OBSOLETE_PREFIXES = /* @__PURE__ */ new Set(["typing", "task-view"]);
 function isLegacyDocId(decoded) {
   if (decoded.startsWith("v2:")) return true;
   return LEGACY_PREFIXES.some((prefix) => decoded.startsWith(`${prefix}:`));
 }
 function shouldPrune(decoded, currentEpoch) {
+  const firstColon = decoded.indexOf(":");
+  if (firstColon > 0 && OBSOLETE_PREFIXES.has(decoded.slice(0, firstColon))) return true;
   const parsed = parseDocumentId(decoded);
   if (!parsed) return isLegacyDocId(decoded);
-  if (OBSOLETE_PREFIXES.has(parsed.prefix)) return true;
   return parsed.epoch < currentEpoch;
 }
 async function pruneOldEpochData(dataDir, currentEpoch, log) {
@@ -88445,6 +88565,12 @@ function handleFileIOChannel(initialCwd, send, log, deps) {
       case "git_ls_files":
         handleGitLsFiles(msg.requestId);
         break;
+      case "git_branch_diff_files":
+        handleGitBranchDiffFiles(msg.requestId, msg.baseRef);
+        break;
+      case "git_branch_diff_file":
+        handleGitBranchDiffFile(msg.requestId, msg.path, msg.mergeBase);
+        break;
       default:
         assertNever(msg);
     }
@@ -88546,6 +88672,79 @@ function handleFileIOChannel(initialCwd, send, log, deps) {
       respondError(requestId, formatError(err));
     }
   }
+  async function handleGitBranchDiffFiles(requestId, baseRefOverride) {
+    try {
+      const baseRef = baseRefOverride ?? await getDefaultBranch(cwd);
+      if (!baseRef) {
+        respond({
+          type: "git_branch_diff_files_result",
+          requestId,
+          files: [],
+          mergeBase: "",
+          baseRef: ""
+        });
+        return;
+      }
+      const mergeBase = await getMergeBase(cwd, baseRef);
+      if (!mergeBase) {
+        respond({
+          type: "git_branch_diff_files_result",
+          requestId,
+          files: [],
+          mergeBase: "",
+          baseRef
+        });
+        return;
+      }
+      const { stdout } = await execFileAsync3(
+        "git",
+        ["diff", "--name-status", `${mergeBase}..HEAD`],
+        { cwd, maxBuffer: 10 * 1024 * 1024 }
+      );
+      const files = stdout.split("\n").filter(Boolean).map((line) => {
+        const parts = line.split("	");
+        const statusCode = parts[0] ?? "";
+        const filePath = parts[1] ?? "";
+        let status;
+        if (statusCode === "A") {
+          status = "added";
+        } else if (statusCode === "D") {
+          status = "deleted";
+        } else {
+          status = "modified";
+        }
+        return { path: filePath, status, insertions: 0, deletions: 0 };
+      });
+      respond({
+        type: "git_branch_diff_files_result",
+        requestId,
+        files,
+        mergeBase,
+        baseRef
+      });
+    } catch (err) {
+      respondError(requestId, formatError(err));
+    }
+  }
+  async function handleGitBranchDiffFile(requestId, filePath, mergeBase) {
+    try {
+      const originalContent = await readGitObject(`${mergeBase}:${filePath}`) ?? "";
+      let modifiedContent;
+      try {
+        modifiedContent = await readFile25(resolve(cwd, filePath), "utf-8");
+      } catch {
+        modifiedContent = "";
+      }
+      respond({
+        type: "git_branch_diff_file_result",
+        requestId,
+        originalContent,
+        modifiedContent
+      });
+    } catch (err) {
+      respondError(requestId, formatError(err));
+    }
+  }
   async function handleGitDiffFile(requestId, safeRelPath, absPath, cached) {
     try {
       let originalContent = "";
@@ -89030,6 +89229,9 @@ function handleLSPChannel(cwd, send, log) {
       exited = true;
       child = null;
     });
+    proc.stdin?.on("error", (err) => {
+      log({ event: "lsp_stdin_error", error: err.message });
+    });
     log({ event: "lsp_spawned", pid: proc.pid });
     return proc;
   }
@@ -89066,8 +89268,13 @@ function handleLSPChannel(cwd, send, log) {
     const header = `Content-Length: ${Buffer.byteLength(data)}\r
 \r
 `;
-    child.stdin?.write(header);
-    child.stdin?.write(data);
+    try {
+      child.stdin?.write(header);
+      child.stdin?.write(data);
+    } catch {
+      log({ event: "lsp_write_failed", exited });
+      child = null;
+    }
   }
   function dispose() {
     disposed = true;
@@ -89248,84 +89455,94 @@ function createPeerManager(config2) {
     return factoryPromise;
   }
   function handleDataChannel(machineId, event) {
-    config2.onPeerDataChannel?.(machineId);
-    const channel = event.channel;
-    const label = channel.label ?? "";
-    const route = routeDataChannel(label);
-    switch (route.kind) {
-      case "thread_messages": {
-        config2.log.debug(
-          { machineId, taskId: route.taskId, threadId: route.threadId },
-          "Thread messages data channel received"
-        );
-        config2.onThreadMessageChannel?.(machineId, event.channel, route.taskId, route.threadId);
-        return;
-      }
-      case "task_messages": {
-        config2.log.debug(
-          { machineId, taskId: route.taskId },
-          "Task messages data channel received"
-        );
-        config2.onTaskMessageChannel?.(machineId, event.channel, route.taskId);
-        return;
-      }
-      case "daemon_control": {
-        config2.log.info({ machineId }, "Daemon control data channel received");
-        config2.onControlChannel?.(machineId, event.channel);
-        return;
-      }
-      case "loro_sync": {
-        config2.log.info({ machineId }, "Loro sync data channel received");
-        const rawChannel = event.channel;
-        guardLoroChannelSend(rawChannel, config2.log);
-        config2.webrtcAdapter.attachDataChannel(
-          machineIdToPeerId(machineId),
-          event.channel
-        );
-        return;
-      }
-      case "file_io": {
-        config2.log.debug({ machineId, id: route.id }, "File I/O data channel received");
-        config2.onFileIOChannel?.(machineId, event.channel, route.id);
-        return;
-      }
-      case "lsp": {
-        config2.log.debug({ machineId, id: route.id }, "LSP data channel received");
-        config2.onLSPChannel?.(machineId, event.channel, route.id);
-        return;
-      }
-      case "browser_preview": {
-        config2.log.debug({ machineId, port: route.port }, "Browser preview data channel received");
-        config2.onBrowserPreviewChannel?.(machineId, event.channel, route.port);
-        return;
-      }
-      case "browser_preview_url": {
-        config2.log.debug({ machineId }, "Browser preview URL data channel received");
-        config2.onBrowserPreviewUrlChannel?.(machineId, event.channel);
-        return;
-      }
-      case "terminal": {
-        config2.log.debug(
-          { machineId, taskId: route.taskId, terminalId: route.terminalId },
-          "Terminal data channel received"
-        );
-        config2.onTerminalChannel?.(machineId, event.channel, route.taskId, route.terminalId);
-        return;
-      }
-      case "asset_transfer": {
-        config2.log.debug({ machineId }, "Asset transfer data channel received");
-        config2.onAssetTransferChannel?.(machineId, event.channel);
-        return;
-      }
-      case "unknown": {
-        config2.log.warn(
-          { machineId, label: route.label },
-          "Ignoring unrecognized data channel label"
-        );
-        return;
+    try {
+      config2.onPeerDataChannel?.(machineId);
+      const channel = event.channel;
+      const label = channel.label ?? "";
+      const route = routeDataChannel(label);
+      switch (route.kind) {
+        case "thread_messages": {
+          config2.log.debug(
+            { machineId, taskId: route.taskId, threadId: route.threadId },
+            "Thread messages data channel received"
+          );
+          config2.onThreadMessageChannel?.(machineId, event.channel, route.taskId, route.threadId);
+          return;
+        }
+        case "task_messages": {
+          config2.log.debug(
+            { machineId, taskId: route.taskId },
+            "Task messages data channel received"
+          );
+          config2.onTaskMessageChannel?.(machineId, event.channel, route.taskId);
+          return;
+        }
+        case "daemon_control": {
+          config2.log.info({ machineId }, "Daemon control data channel received");
+          config2.onControlChannel?.(machineId, event.channel);
+          return;
+        }
+        case "loro_sync": {
+          config2.log.info({ machineId }, "Loro sync data channel received");
+          const rawChannel = event.channel;
+          guardLoroChannelSend(rawChannel, config2.log);
+          config2.webrtcAdapter.attachDataChannel(
+            machineIdToPeerId(machineId),
+            event.channel
+          );
+          return;
+        }
+        case "file_io": {
+          config2.log.debug({ machineId, id: route.id }, "File I/O data channel received");
+          config2.onFileIOChannel?.(machineId, event.channel, route.id);
+          return;
+        }
+        case "lsp": {
+          config2.log.debug({ machineId, id: route.id }, "LSP data channel received");
+          config2.onLSPChannel?.(machineId, event.channel, route.id);
+          return;
+        }
+        case "browser_preview": {
+          config2.log.debug(
+            { machineId, port: route.port },
+            "Browser preview data channel received"
+          );
+          config2.onBrowserPreviewChannel?.(machineId, event.channel, route.port);
+          return;
+        }
+        case "browser_preview_url": {
+          config2.log.debug({ machineId }, "Browser preview URL data channel received");
+          config2.onBrowserPreviewUrlChannel?.(machineId, event.channel);
+          return;
+        }
+        case "terminal": {
+          config2.log.debug(
+            { machineId, taskId: route.taskId, terminalId: route.terminalId },
+            "Terminal data channel received"
+          );
+          config2.onTerminalChannel?.(machineId, event.channel, route.taskId, route.terminalId);
+          return;
+        }
+        case "asset_transfer": {
+          config2.log.debug({ machineId }, "Asset transfer data channel received");
+          config2.onAssetTransferChannel?.(machineId, event.channel);
+          return;
+        }
+        case "unknown": {
+          config2.log.warn(
+            { machineId, label: route.label },
+            "Ignoring unrecognized data channel label"
+          );
+          return;
+        }
+        default:
+          assertNever3(route);
       }
-      default:
-        assertNever3(route);
+    } catch (err) {
+      config2.log.warn(
+        { machineId, err: err instanceof Error ? err.message : String(err) },
+        "Data channel routing failed (peer connection likely closing)"
+      );
     }
   }
   function setupPeerHandlers(machineId, pc) {
@@ -89347,6 +89564,7 @@ function createPeerManager(config2) {
       if (state === "failed" || state === "closed") {
         config2.webrtcAdapter.detachDataChannel(machineIdToPeerId(machineId));
         peers.delete(machineId);
+        pc.onconnectionstatechange = null;
         pc.close();
       }
     };
@@ -89402,7 +89620,20 @@ function createPeerManager(config2) {
         if (!pc.createOffer) {
           throw new Error("PeerConnection does not support createOffer");
         }
-        const channel = pc.createDataChannel(LORO_SYNC_LABEL, { ordered: true });
+        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)"
+          );
+          pendingCreates.delete(targetMachineId);
+          peers.delete(targetMachineId);
+          pc.onconnectionstatechange = null;
+          pc.close();
+          throw err;
+        }
         const rawChannel = channel;
         guardLoroChannelSend(rawChannel, config2.log);
         rawChannel.onopen = () => {
@@ -89461,6 +89692,7 @@ function createPeerManager(config2) {
       const pc = peers.get(targetId);
       if (pc) {
         config2.webrtcAdapter.detachDataChannel(machineIdToPeerId(targetId));
+        pc.onconnectionstatechange = null;
         pc.close();
         peers.delete(targetId);
       }
@@ -89468,6 +89700,7 @@ function createPeerManager(config2) {
     destroy() {
       for (const [machineId, pc] of peers) {
         config2.webrtcAdapter.detachDataChannel(machineIdToPeerId(machineId));
+        pc.onconnectionstatechange = null;
         pc.close();
       }
       peers.clear();
@@ -91478,7 +91711,16 @@ function attachConversationHandler(daemon, dc, channelId, params, log, attempts)
   const handlerOpts = {
     taskId,
     channelId,
-    send: (data) => dc.send(data),
+    send: (data) => {
+      try {
+        dc.send(data);
+      } catch (err) {
+        log({
+          event: "message_channel_send_failed",
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    },
     taskManager: daemon.taskManager,
     store: daemon.store,
     log,
@@ -91602,7 +91844,16 @@ function wireThreadErrorFallback(daemon, dc, taskId, threadId, channelId, log) {
   const handler = handleMessageChannel({
     taskId,
     channelId,
-    send: (data) => dc.send(data),
+    send: (data) => {
+      try {
+        dc.send(data);
+      } catch (err) {
+        log({
+          event: "message_channel_send_failed",
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    },
     taskManager: daemon.taskManager,
     store: daemon.store,
     log,
@@ -91647,15 +91898,19 @@ function routeSignalingMessage(peerManager, signalingHandle, log) {
     switch (msg.type) {
       case "webrtc-offer":
         if (msg.fromMachineId)
-          peerManager?.handleOffer(msg.fromMachineId, toSDPDescription(msg.offer));
+          peerManager?.handleOffer(msg.fromMachineId, toSDPDescription(msg.offer)).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));
+          peerManager?.handleAnswer(msg.fromMachineId, toSDPDescription(msg.answer)).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));
+          peerManager?.handleIce(msg.fromMachineId, toICECandidate(msg.candidate)).catch((err) => log.error({ event: "webrtc_ice_failed", error: String(err) }));
         break;
       case "ice-servers":
         peerManager?.updateIceServers(msg.iceServers);
@@ -91696,4 +91951,4 @@ export {
   classifyLogLevel,
   serve
 };
-//# sourceMappingURL=serve-HDRZ2CU6.js.map
+//# sourceMappingURL=serve-ZD5RISIM.js.map