@schoolai/shipyard 0.6.0 → 0.8.0-rc.20260221

package/dist/index.js

@@ -12,7 +12,7 @@ import {
   PersonalRoomConnection,
   ROUTES,
   ValidationErrorResponseSchema
-} from "./chunk-CQBP5B4G.js";
+} from "./chunk-OTIQVES4.js";
 import {
   __export,
   getShipyardHome,
@@ -11331,13 +11331,16 @@ var TaskDocumentSchema = Shape.doc({
     updatedAt: Shape.plain.number()
   }),
   conversation: Shape.list(MessageShape),
+  pendingFollowUps: Shape.list(MessageShape),
   sessions: Shape.list(SessionEntryShape),
   diffState: DiffStateShape,
   plans: Shape.list(PlanVersionShape),
   planEditorDocs: Shape.record(Shape.any()),
   diffComments: Shape.record(DiffCommentShape),
-  planComments: Shape.record(PlanCommentShape)
+  planComments: Shape.record(PlanCommentShape),
+  deliveredCommentIds: Shape.list(Shape.plain.string())
 });
+var TERMINAL_TASK_STATES = ["completed", "failed", "canceled"];
 var TOOL_RISK_LEVELS = ["low", "medium", "high"];
 var PERMISSION_DECISIONS = ["approved", "denied"];
 var PermissionRequestEphemeral = Shape.plain.struct({
@@ -11392,7 +11395,10 @@ var WorktreeScriptShape = Shape.plain.struct({
   script: Shape.plain.string()
 });
 var UserSettingsShape = Shape.struct({
-  worktreeScripts: Shape.record(WorktreeScriptShape)
+  worktreeScripts: Shape.record(WorktreeScriptShape),
+  composerModel: Shape.plain.string().nullable(),
+  composerReasoning: Shape.plain.string(...REASONING_EFFORTS).nullable(),
+  composerPermission: Shape.plain.string(...PERMISSION_MODES).nullable()
 });
 var TaskIndexDocumentSchema = Shape.doc({
   taskIndex: Shape.record(TaskIndexEntryShape),
@@ -12759,13 +12765,17 @@ function recoverOrphanedTask(taskDoc, log) {
 
 // src/peer-manager.ts
 var ICE_SERVERS = [{ urls: "stun:stun.l.google.com:19302" }];
+var MAX_MESSAGE_SIZE = 16 * 1024 * 1024;
 function machineIdToPeerId(machineId) {
   return machineId;
 }
 async function loadDefaultFactory() {
   const { RTCPeerConnection } = await import("node-datachannel/polyfill");
   return () => {
-    const pc = new RTCPeerConnection({ iceServers: ICE_SERVERS });
+    const pc = new RTCPeerConnection({
+      iceServers: ICE_SERVERS,
+      maxMessageSize: MAX_MESSAGE_SIZE
+    });
     return pc;
   };
 }
@@ -12909,6 +12919,40 @@ function createPeerManager(config2) {
   };
 }
 
+// src/plan-editor/format-diff-feedback.ts
+function formatDiffFeedbackForClaudeCode(comments, generalFeedback) {
+  const sections = [];
+  if (generalFeedback) {
+    sections.push("## General Feedback\n");
+    sections.push(generalFeedback);
+    sections.push("");
+  }
+  if (comments.length > 0) {
+    appendCommentSection(sections, comments);
+  }
+  return sections.join("\n").trim();
+}
+function appendCommentSection(sections, comments) {
+  sections.push("## Inline Comments on Code Changes\n");
+  sections.push("The user left the following comments on the diff:\n");
+  const byFile = /* @__PURE__ */ new Map();
+  for (const c of comments) {
+    const existing = byFile.get(c.filePath) ?? [];
+    existing.push(c);
+    byFile.set(c.filePath, existing);
+  }
+  for (const [filePath, fileComments] of byFile) {
+    sections.push(`### ${filePath}
+`);
+    const sorted = [...fileComments].sort((a, b) => a.lineNumber - b.lineNumber);
+    for (const comment2 of sorted) {
+      const sideLabel = comment2.side === "old" ? "before change" : "after change";
+      sections.push(`> Line ${comment2.lineNumber} (${sideLabel}): ${comment2.body}`);
+    }
+    sections.push("");
+  }
+}
+
 // src/plan-editor/format-plan-feedback.ts
 function formatPlanFeedbackForClaudeCode(original, edited, comments, generalFeedback) {
   const sections = [];
@@ -12918,7 +12962,7 @@ function formatPlanFeedbackForClaudeCode(original, edited, comments, generalFeed
     sections.push("");
   }
   if (comments.length > 0) {
-    appendCommentSection(sections, comments, edited);
+    appendCommentSection2(sections, comments, edited);
   }
   if (original !== edited) {
     sections.push("## Edits Made\n");
@@ -12930,7 +12974,7 @@ function formatPlanFeedbackForClaudeCode(original, edited, comments, generalFeed
   }
   return sections.join("\n").trim();
 }
-function appendCommentSection(sections, comments, edited) {
+function appendCommentSection2(sections, comments, edited) {
   sections.push("## Inline Comments\n");
   sections.push("The user left the following comments on specific parts of the plan:\n");
   const editedLines = edited.split("\n");
@@ -41672,7 +41716,8 @@ var SessionManager = class {
    * Determine whether to resume an existing session or start fresh.
    *
    * Walks backwards through sessions to find the most recent one with a
-   * non-empty agentSessionId that has not failed. If found, returns
+   * non-empty agentSessionId that has not genuinely failed. Interrupted
+   * (user-cancelled) sessions are resumable. If found, returns
    * { resume: true, sessionId } so the caller can pass it to resumeSession().
    */
   shouldResume() {
@@ -41743,7 +41788,7 @@ var SessionManager = class {
     });
     this.#inputController = controller;
     this.#activeQuery = response;
-    return this.#processMessages(response, sessionId);
+    return this.#processMessages(response, sessionId, opts.abortController);
   }
   /**
    * Send a follow-up message to the active streaming session.
@@ -41778,6 +41823,9 @@ var SessionManager = class {
     await this.#activeQuery?.setModel(model);
     this.#currentModel = model;
   }
+  async setPermissionMode(mode) {
+    await this.#activeQuery?.setPermissionMode(mode);
+  }
   /**
    * Resume an existing Claude Code session using streaming input mode.
    * Looks up the agentSessionId from the task doc and passes it as `resume`.
@@ -41839,9 +41887,9 @@ var SessionManager = class {
     });
     this.#inputController = controller;
     this.#activeQuery = response;
-    return this.#processMessages(response, newSessionId);
+    return this.#processMessages(response, newSessionId, opts?.abortController);
   }
-  async #processMessages(response, sessionId) {
+  async #processMessages(response, sessionId, abortController) {
     let agentSessionId = "";
     let lastMessageAt = Date.now();
     let idleTimedOut = false;
@@ -41868,14 +41916,13 @@ var SessionManager = class {
         }
       }
     } catch (error2) {
-      const errorMsg2 = idleTimedOut ? "Session idle timeout exceeded" : error2 instanceof Error ? error2.message : String(error2);
-      this.#markFailed(sessionId, errorMsg2);
-      return {
+      return this.#handleProcessError(
+        error2,
         sessionId,
         agentSessionId,
-        status: "failed",
-        error: errorMsg2
-      };
+        idleTimedOut,
+        abortController
+      );
     } finally {
       clearInterval(idleTimer);
       this.#inputController = null;
@@ -42113,6 +42160,28 @@ var SessionManager = class {
       error: !isSuccess ? errorText ?? message.subtype : void 0
     };
   }
+  #handleProcessError(error2, sessionId, agentSessionId, idleTimedOut, abortController) {
+    if (abortController?.signal.aborted) {
+      this.#markInterrupted(sessionId);
+      return { sessionId, agentSessionId, status: "interrupted" };
+    }
+    const errorMsg = idleTimedOut ? "Session idle timeout exceeded" : error2 instanceof Error ? error2.message : String(error2);
+    this.#markFailed(sessionId, errorMsg);
+    return { sessionId, agentSessionId, status: "failed", error: errorMsg };
+  }
+  #markInterrupted(sessionId) {
+    const idx = this.#findSessionIndex(sessionId);
+    change(this.#taskDoc, (draft) => {
+      const session = idx >= 0 ? draft.sessions.get(idx) : void 0;
+      if (session) {
+        session.status = "interrupted";
+        session.completedAt = Date.now();
+      }
+      draft.meta.status = "canceled";
+      draft.meta.updatedAt = Date.now();
+    });
+    this.#notifyStatusChange("canceled");
+  }
   #markFailed(sessionId, errorMsg) {
     const idx = this.#findSessionIndex(sessionId);
     change(this.#taskDoc, (draft) => {
@@ -42488,6 +42557,34 @@ var TaskEphemeralDeclarations = {
   permReqs: PermissionRequestEphemeral,
   permResps: PermissionResponseEphemeral
 };
+var TERMINAL_STATUSES = new Set(TERMINAL_TASK_STATES);
+async function rehydrateTaskDocuments(roomHandle, roomDoc, repo, log) {
+  try {
+    await roomHandle.waitForSync({ kind: "storage", timeout: 5e3 });
+  } catch {
+    log.warn(
+      "Room doc storage sync timed out during rehydration \u2014 task rehydration may be incomplete"
+    );
+  }
+  const roomJson = roomDoc.toJSON();
+  const taskEntries = Object.entries(roomJson.taskIndex ?? {});
+  log.info({ count: taskEntries.length }, "Rehydrating task documents from storage");
+  for (const [taskId, entry] of taskEntries) {
+    if (TERMINAL_STATUSES.has(entry.status)) continue;
+    try {
+      const taskDocId = buildDocumentId("task", taskId, DEFAULT_EPOCH);
+      const taskHandle = repo.get(taskDocId, TaskDocumentSchema, TaskEphemeralDeclarations);
+      await taskHandle.waitForSync({ kind: "storage", timeout: 5e3 });
+      if (recoverOrphanedTask(taskHandle.doc, createChildLogger({ mode: "rehydrate", taskId }))) {
+        updateTaskInIndex(roomDoc, taskId, { status: "failed", updatedAt: Date.now() });
+      }
+      log.debug({ taskId, taskDocId }, "Task document rehydrated");
+    } catch (err) {
+      log.warn({ taskId, err }, "Failed to rehydrate task document");
+    }
+  }
+  log.info("Task document rehydration complete");
+}
 async function serve(env) {
   if (!env.SHIPYARD_SIGNALING_URL) {
     logger.error("SHIPYARD_SIGNALING_URL is required for serve mode");
@@ -42520,6 +42617,7 @@ async function serve(env) {
   const activeTasks = /* @__PURE__ */ new Map();
   const watchedTasks = /* @__PURE__ */ new Map();
   const taskHandles = /* @__PURE__ */ new Map();
+  const lastProcessedConvLen = /* @__PURE__ */ new Map();
   const devSuffix = env.SHIPYARD_DEV ? "-dev" : "";
   const machineId = env.SHIPYARD_MACHINE_ID ?? `${hostname2()}${devSuffix}`;
   const dataDir = resolve(env.SHIPYARD_DATA_DIR.replace("~", homedir2()));
@@ -42733,6 +42831,7 @@ async function serve(env) {
   const typedRoomHandle = roomHandle;
   const typedRoomDoc = roomHandle.doc;
   cleanupStaleSetupEntries(typedRoomDoc, machineId, log);
+  await rehydrateTaskDocuments(roomHandle, typedRoomDoc, repo, log);
   typedRoomHandle.enhancePromptReqs.subscribe(({ key: requestId, value, source }) => {
     if (source !== "remote") return;
     if (!value) return;
@@ -42904,6 +43003,7 @@ async function serve(env) {
       activeTasks,
       watchedTasks,
       taskHandles,
+      lastProcessedConvLen,
       peerManager,
       env,
       machineId,
@@ -42935,6 +43035,7 @@ async function serve(env) {
     }
     watchedTasks.clear();
     taskHandles.clear();
+    lastProcessedConvLen.clear();
     for (const timer of pendingCleanupTimers) clearTimeout(timer);
     pendingCleanupTimers.clear();
     for (const [id, ptyMgr] of terminalPtys) {
@@ -43109,6 +43210,12 @@ function handleMessage(msg, ctx) {
     case "worktree-create-error":
       ctx.log.debug({ type: msg.type }, "Worktree create echo");
       break;
+    case "cancel-task":
+      handleCancelTask(msg, ctx);
+      break;
+    case "control-ack":
+      ctx.log.debug({ type: msg.type }, "Control ack echo");
+      break;
     case "authenticated":
     case "agent-joined":
     case "agent-left":
@@ -43160,6 +43267,32 @@ function handleNotifyTask(msg, ctx) {
     taskLog.error({ err: errMsg }, "Failed to start watching task document");
   });
 }
+function handleCancelTask(msg, ctx) {
+  const { taskId, requestId } = msg;
+  const taskLog = createChildLogger({ mode: "serve", taskId });
+  const activeTask = ctx.activeTasks.get(taskId);
+  if (!activeTask) {
+    taskLog.warn("Cancel requested but no active task found");
+    ctx.connection.send({
+      type: "control-ack",
+      requestId,
+      taskId,
+      action: "cancel",
+      accepted: false,
+      error: "No active agent running for this task"
+    });
+    return;
+  }
+  taskLog.info("Canceling active task");
+  activeTask.abortController.abort();
+  ctx.connection.send({
+    type: "control-ack",
+    requestId,
+    taskId,
+    action: "cancel",
+    accepted: true
+  });
+}
 var ENHANCE_PROMPT_TIMEOUT_MS = 3e4;
 var ENHANCE_SYSTEM_PROMPT = `You are a prompt rewriter that transforms rough user requests into clear, specific instructions for an AI coding assistant (Claude Code). The enhanced prompt will be sent AS the user's message to that assistant.
 
@@ -43586,12 +43719,15 @@ async function watchTaskDocument(taskId, taskLog, ctx) {
   try {
     await taskHandle.waitForSync({ kind: "storage", timeout: 5e3 });
   } catch {
-    taskLog.debug({ taskDocId }, "No existing task data in storage");
+    taskLog.info({ taskDocId }, "No existing task data in storage");
   }
   try {
     await taskHandle.waitForSync({ kind: "network", timeout: 3e3 });
   } catch {
-    taskLog.debug({ taskDocId }, "Network sync timed out (browser may not be connected yet)");
+    taskLog.warn(
+      { taskDocId, timeoutMs: 3e3 },
+      "Network sync timed out (browser may not be connected yet)"
+    );
   }
   if (recoverOrphanedTask(taskHandle.doc, taskLog)) {
     updateTaskInIndex(ctx.roomDoc, taskId, { status: "failed", updatedAt: Date.now() });
@@ -43622,28 +43758,50 @@ async function watchTaskDocument(taskId, taskLog, ctx) {
     onTaskDocChanged(taskId, taskHandle, taskLog, ctx);
   }
 }
-function handleFollowUp(activeTask, conversationLen, taskLog) {
+function promotePendingFollowUps(taskHandle, activeTask, taskLog) {
   if (!activeTask) return;
-  if (conversationLen <= activeTask.lastDispatchedConvLen) {
-    taskLog.debug(
-      { conversationLen, lastDispatched: activeTask.lastDispatchedConvLen },
-      "Conversation unchanged since last dispatch, skipping duplicate"
-    );
+  if (activeTask.abortController.signal.aborted) {
+    taskLog.debug("Task is being aborted, skipping pending follow-up promotion");
     return;
   }
+  const json = taskHandle.doc.toJSON();
+  const pending = json.pendingFollowUps ?? [];
+  if (pending.length === 0) return;
+  change(taskHandle.doc, (draft) => {
+    const items = draft.pendingFollowUps.toArray();
+    for (const msg of items) {
+      draft.conversation.push(msg);
+    }
+    if (draft.pendingFollowUps.length > 0) {
+      draft.pendingFollowUps.delete(0, draft.pendingFollowUps.length);
+    }
+  });
+  taskLog.info({ pendingCount: pending.length }, "Promoted pending follow-ups to conversation");
   if (!activeTask.sessionManager.isStreaming) {
-    taskLog.debug("Task already running but not streaming, skipping");
+    taskLog.debug("Task not streaming, skipping follow-up dispatch");
     return;
   }
-  const contentBlocks = activeTask.sessionManager.getLatestUserContentBlocks();
-  if (contentBlocks && contentBlocks.length > 0) {
+  const allContentBlocks = pending.flatMap(
+    (msg) => msg.content.filter((block2) => block2.type === "text" || block2.type === "image")
+  );
+  if (allContentBlocks.length === 0) return;
+  const dispatchFollowUp = () => {
     try {
-      taskLog.info("Sending follow-up to active streaming session");
-      activeTask.lastDispatchedConvLen = conversationLen;
-      activeTask.sessionManager.sendFollowUp(contentBlocks);
+      activeTask.lastDispatchedConvLen = json.conversation.length + pending.length;
+      activeTask.sessionManager.sendFollowUp(allContentBlocks);
     } catch (err) {
-      taskLog.warn({ err }, "Failed to send follow-up to streaming session");
+      taskLog.warn({ err }, "Failed to send promoted follow-up");
     }
+  };
+  const lastPending = pending[pending.length - 1];
+  const mappedMode = lastPending?.permissionMode ? mapPermissionMode(lastPending.permissionMode) : void 0;
+  if (mappedMode) {
+    activeTask.sessionManager.setPermissionMode(mappedMode).then(dispatchFollowUp).catch((err) => {
+      taskLog.warn({ err }, "Failed to update permission mode from queued message");
+      dispatchFollowUp();
+    });
+  } else {
+    dispatchFollowUp();
   }
 }
 function onTaskDocChanged(taskId, taskHandle, taskLog, ctx) {
@@ -43659,22 +43817,35 @@ function onTaskDocChanged(taskId, taskHandle, taskLog, ctx) {
     "onTaskDocChanged evaluation"
   );
   if (ctx.activeTasks.has(taskId)) {
-    const conversation2 = json.conversation;
-    const lastMessage2 = conversation2[conversation2.length - 1];
-    if (lastMessage2?.role === "user") {
-      handleFollowUp(ctx.activeTasks.get(taskId), conversation2.length, taskLog);
+    const pendingFollowUps2 = json.pendingFollowUps ?? [];
+    if (pendingFollowUps2.length > 0) {
+      promotePendingFollowUps(taskHandle, ctx.activeTasks.get(taskId), taskLog);
     }
+    const conversation2 = json.conversation;
     const activeLastUserMsg = [...conversation2].reverse().find((m) => m.role === "user");
     const activeCwd = activeLastUserMsg?.cwd ?? process.cwd();
     debouncedDiffCapture(taskId, activeCwd, taskHandle, taskLog);
     debouncedBranchDiffCapture(taskId, activeCwd, taskHandle, taskLog);
     return;
   }
-  if (json.meta.status === "working" || json.meta.status === "input-required" || json.meta.status === "starting") {
-    taskLog.debug({ status: json.meta.status }, "Status blocks new work, skipping");
-    return;
+  const pendingFollowUps = json.pendingFollowUps ?? [];
+  if (pendingFollowUps.length > 0) {
+    taskLog.info(
+      { pendingCount: pendingFollowUps.length },
+      "Promoting orphaned pending follow-ups"
+    );
+    change(taskHandle.doc, (draft) => {
+      const items = draft.pendingFollowUps.toArray();
+      for (const msg of items) {
+        draft.conversation.push(msg);
+      }
+      if (draft.pendingFollowUps.length > 0) {
+        draft.pendingFollowUps.delete(0, draft.pendingFollowUps.length);
+      }
+    });
   }
-  const conversation = json.conversation;
+  const freshJson = taskHandle.doc.toJSON();
+  const conversation = freshJson.conversation;
   if (conversation.length === 0) {
     taskLog.debug("No conversation messages, skipping");
     return;
@@ -43683,7 +43854,18 @@ function onTaskDocChanged(taskId, taskHandle, taskLog, ctx) {
   if (!lastMessage || lastMessage.role !== "user") {
     return;
   }
-  taskLog.info("New user message detected, starting agent");
+  const prevLen = ctx.lastProcessedConvLen.get(taskId) ?? 0;
+  if (conversation.length <= prevLen) {
+    taskLog.debug(
+      { conversationLen: conversation.length, lastProcessed: prevLen },
+      "No new messages since last run, skipping"
+    );
+    return;
+  }
+  taskLog.info(
+    { prevLen, newLen: conversation.length },
+    "New user message detected, starting agent"
+  );
   const cwd = lastMessage.cwd ?? process.cwd();
   const model = lastMessage.model ?? void 0;
   const permissionMode = mapPermissionMode(lastMessage.permissionMode);
@@ -43700,6 +43882,7 @@ function onTaskDocChanged(taskId, taskHandle, taskLog, ctx) {
     lastDispatchedConvLen: conversation.length
   };
   ctx.activeTasks.set(taskId, activeTask);
+  ctx.lastProcessedConvLen.set(taskId, conversation.length);
   ctx.signaling.updateStatus("running", taskId);
   const turnStartRefPromise = captureTreeSnapshot(cwd);
   turnStartRefPromise.then((ref) => taskLog.debug({ turnStartRef: ref }, "Captured turn start snapshot")).catch((err) => taskLog.warn({ err }, "Failed to capture turn start snapshot"));
@@ -43746,6 +43929,7 @@ async function cleanupTaskRun(opts) {
   const { taskId, cwd, taskHandle, taskLog, turnStartRefPromise, abortController, ctx } = opts;
   const activeTask = ctx.activeTasks.get(taskId);
   activeTask?.sessionManager.closeSession();
+  abortController.abort();
   clearDebouncedTimer(diffDebounceTimers, taskId);
   clearDebouncedTimer(branchDiffTimers, taskId);
   try {
@@ -43764,7 +43948,6 @@ async function cleanupTaskRun(opts) {
   } catch (err) {
     taskLog.warn({ err }, "Failed to capture turn diff");
   }
-  abortController.abort();
   for (const [key] of taskHandle.permReqs.getAll()) {
     taskHandle.permReqs.delete(key);
   }
@@ -43773,6 +43956,7 @@ async function cleanupTaskRun(opts) {
   }
   ctx.activeTasks.delete(taskId);
   ctx.signaling.updateStatus("idle");
+  onTaskDocChanged(taskId, taskHandle, taskLog, ctx);
 }
 function clearDebouncedTimer(timers, taskId) {
   const timer = timers.get(taskId);
@@ -43846,6 +44030,19 @@ function resolveExitPlanMode(taskHandle, taskLog, toolUseID, value) {
     "Updated plan reviewStatus in CRDT with rich feedback"
   );
 }
+function resolveAskUserQuestion(taskLog, toolUseID, input, value) {
+  if (value.decision !== "approved" || !value.message) return input;
+  try {
+    const parsed = JSON.parse(value.message);
+    if ("answers" in parsed && parsed.answers && typeof parsed.answers === "object" && !Array.isArray(parsed.answers)) {
+      taskLog.info({ toolUseID }, "Merged AskUserQuestion answers into input");
+      return { ...input, answers: parsed.answers };
+    }
+  } catch {
+    taskLog.warn({ toolUseID }, "Failed to parse AskUserQuestion answers from message");
+  }
+  return input;
+}
 function resolvePermissionResponse(ctx) {
   const { taskHandle, roomDoc, taskId, taskLog, toolName, toolUseID, input, suggestions, value } = ctx;
   taskHandle.permReqs.delete(toolUseID);
@@ -43858,6 +44055,10 @@ function resolvePermissionResponse(ctx) {
   if (toolName === "ExitPlanMode") {
     resolveExitPlanMode(taskHandle, taskLog, toolUseID, value);
   }
+  let resolvedInput = input;
+  if (toolName === "AskUserQuestion") {
+    resolvedInput = resolveAskUserQuestion(taskLog, toolUseID, input, value);
+  }
   taskLog.info(
     {
       toolName,
@@ -43869,7 +44070,8 @@ function resolvePermissionResponse(ctx) {
     "Permission response received"
   );
   const decision = value.decision === "approved" ? "approved" : "denied";
-  return toPermissionResult(decision, input, suggestions, value.message);
+  const resultMessage = toolName === "AskUserQuestion" && decision === "approved" ? null : value.message;
+  return toPermissionResult(decision, resolvedInput, suggestions, resultMessage);
 }
 function buildCanUseTool(taskHandle, taskLog, roomDoc, taskId) {
   return async (toolName, input, options) => {
@@ -43950,6 +44152,76 @@ function buildCanUseTool(taskHandle, taskLog, roomDoc, taskId) {
     });
   };
 }
+function collectPlanFeedback(unresolvedPlan, plans, loroDoc) {
+  const parts = [];
+  const byPlanId = /* @__PURE__ */ new Map();
+  for (const c of unresolvedPlan) {
+    const existing = byPlanId.get(c.planId) ?? [];
+    existing.push(c);
+    byPlanId.set(c.planId, existing);
+  }
+  for (const [planId, comments] of byPlanId) {
+    const plan = plans.find((p) => p.planId === planId);
+    const originalMarkdown = plan?.markdown ?? "";
+    const editedMarkdown = serializePlanEditorDoc(loroDoc, planId) || originalMarkdown;
+    const feedback = formatPlanFeedbackForClaudeCode(
+      originalMarkdown,
+      editedMarkdown,
+      comments,
+      null
+    );
+    if (feedback) {
+      parts.push(feedback);
+    }
+  }
+  return parts;
+}
+function harvestUndeliveredComments(taskHandle, contentBlocks, log) {
+  const json = taskHandle.doc.toJSON();
+  const deliveredSet = new Set(json.deliveredCommentIds ?? []);
+  const unresolvedDiff = Object.values(json.diffComments).filter(
+    (c) => c.resolvedAt === null && !deliveredSet.has(c.commentId)
+  );
+  const unresolvedPlan = Object.values(json.planComments).filter(
+    (c) => c.resolvedAt === null && !deliveredSet.has(c.commentId)
+  );
+  if (unresolvedDiff.length === 0 && unresolvedPlan.length === 0) {
+    return;
+  }
+  const feedbackParts = [];
+  if (unresolvedDiff.length > 0) {
+    const diffFeedback = formatDiffFeedbackForClaudeCode(unresolvedDiff, null);
+    if (diffFeedback) {
+      feedbackParts.push(diffFeedback);
+    }
+  }
+  if (unresolvedPlan.length > 0) {
+    feedbackParts.push(...collectPlanFeedback(unresolvedPlan, json.plans, taskHandle.loroDoc));
+  }
+  if (feedbackParts.length === 0) {
+    return;
+  }
+  const feedbackText = `
+
+---
+**User feedback on your changes (comments from code review):**
+
+${feedbackParts.join("\n\n")}`;
+  contentBlocks.push({ type: "text", text: feedbackText });
+  const harvestedIds = [
+    ...unresolvedDiff.map((c) => c.commentId),
+    ...unresolvedPlan.map((c) => c.commentId)
+  ];
+  change(taskHandle.doc, (draft) => {
+    for (const id of harvestedIds) {
+      draft.deliveredCommentIds.push(id);
+    }
+  });
+  log.info(
+    { diffCommentCount: unresolvedDiff.length, planCommentCount: unresolvedPlan.length },
+    "Harvested undelivered comments as safety net"
+  );
+}
 async function runTask(opts) {
   const {
     sessionManager: manager,
@@ -43968,13 +44240,14 @@ async function runTask(opts) {
   if (!contentBlocks || contentBlocks.length === 0) {
     throw new Error(`No user message found in task ${taskId}`);
   }
+  harvestUndeliveredComments(taskHandle, contentBlocks, log);
   const textPreview = contentBlocks.filter((b) => b.type === "text").map((b) => b.text).join(" ").slice(0, 100);
   const imageCount = contentBlocks.filter((b) => b.type === "image").length;
   log.info(
     { prompt: textPreview || "(images only)", imageCount },
     "Running task with prompt from CRDT"
   );
-  const canUseTool = permissionMode === "bypassPermissions" ? void 0 : buildCanUseTool(taskHandle, log, roomDoc, taskId);
+  const canUseTool = buildCanUseTool(taskHandle, log, roomDoc, taskId);
   const stderr = (data) => {
     const trimmed = data.trim();
     if (!trimmed) return;
@@ -43995,7 +44268,7 @@ async function runTask(opts) {
       effort,
       canUseTool,
       stderr,
-      allowDangerouslySkipPermissions: permissionMode === "bypassPermissions" ? true : void 0
+      allowDangerouslySkipPermissions: true
     });
   }
   return manager.createSession({
@@ -44008,7 +44281,7 @@ async function runTask(opts) {
     abortController,
     canUseTool,
     stderr,
-    allowDangerouslySkipPermissions: permissionMode === "bypassPermissions" ? true : void 0
+    allowDangerouslySkipPermissions: true
   });
 }
 
@@ -44154,7 +44427,7 @@ function handleResult(log, result, startTime) {
 async function handleSubcommand() {
   const subcommand = process.argv[2];
   if (subcommand === "login") {
-    const { loginCommand } = await import("./login-625HP2EN.js");
+    const { loginCommand } = await import("./login-6TA7RIBE.js");
     const hasCheck = process.argv.includes("--check");
     await loginCommand({ check: hasCheck });
     return true;