@schoolai/shipyard 3.35.0-rc.20260928.1 → 3.35.0-rc.20260928.2

package/dist/electron-utility.js

@@ -71,7 +71,7 @@ async function main() {
   await loadAuthFromConfig(env);
   crumb("post-auth-load");
   crumb("pre-serve-import");
-  const { serve } = await import("./serve-4BO7AOJM.js");
+  const { serve } = await import("./serve-FI5KNQA2.js");
   crumb("post-serve-import");
   const portQueue = [];
   let acceptor = null;

package/dist/index.js

@@ -137,7 +137,7 @@ async function handleSubcommand() {
     return true;
   }
   if (subcommand === "start") {
-    const { startCommand } = await import("./start-LRDGHHRC.js");
+    const { startCommand } = await import("./start-PVWQLLNL.js");
     await startCommand();
     return true;
   }
@@ -159,7 +159,7 @@ async function main() {
   const args = parseCliArgs();
   if (args.serve) {
     await loadAuthFromConfig(env);
-    const { serve } = await import("./serve-4BO7AOJM.js");
+    const { serve } = await import("./serve-FI5KNQA2.js");
     return serve({ isDev: env.SHIPYARD_DEV });
   }
   logger.error("Use `shipyard start` to run the daemon. Use --help for usage.");

package/dist/{serve-4BO7AOJM.js → serve-FI5KNQA2.js}

@@ -39455,8 +39455,13 @@ var MessageAdmissionCancelledError = class extends Error {
   }
 };
 var AutomaticTurnRefusedError = class extends MessageAdmissionCancelledError {
-  constructor() {
-    super("Automatic turn refused: the task was stopped or the daemon is shutting down");
+  /** `stopped`: the task was stopped, paused, completed or archived. `shutdown`: the daemon is going down, so the turn is owed to the next boot. */
+  reason;
+  constructor(reason) {
+    super(
+      `Automatic turn refused: ${reason === "stopped" ? "the task was stopped" : "the daemon is shutting down"}`
+    );
+    this.reason = reason;
   }
 };
 var TaskConversationMutations = class {
@@ -39707,6 +39712,7 @@ async function bootInterruptedTurnResume(deps) {
     resumeBlocker: deps.resumeBlocker,
     sendResume: deps.sendResume,
     automaticEpoch: deps.automaticEpoch,
+    carryToNextBoot: deps.carryToNextBoot,
     queue: deps.queue,
     tracker: deps.tracker
   });
@@ -39773,6 +39779,10 @@ function slotLossReason(reason) {
       return assertNever(reason.loss);
   }
 }
+function isShutdownRefusal(err3, deps) {
+  if (err3 instanceof AutomaticTurnRefusedError) return err3.reason === "shutdown";
+  return err3 instanceof MessageAdmissionCancelledError && deps.isCancelled();
+}
 var ResumeLostError = class extends Error {
   reason;
   constructor(reason) {
@@ -39823,26 +39833,31 @@ async function sendOneResume(taskId, attempts, deps, slot) {
   } catch (err3) {
     slot.signal.removeEventListener("abort", onLost);
     if (lostEarly) return false;
-    if (sent && err3 instanceof MessageAdmissionCancelledError) {
-      deps.tracker.markSendFailed(taskId);
-      await attempts.release(taskId);
-      return abandon(taskId, "cancelled_before_turn", deps);
-    }
-    if (sent) {
-      deps.tracker.markSendFailed(taskId);
-    } else if (err3 instanceof ResumeLostError) {
-      await attempts.release(taskId);
-      return abandon(taskId, err3.reason, deps);
-    } else {
-      deps.tracker.markDropped(taskId);
-    }
-    deps.log({
-      event: "interrupted_resume_failed",
-      taskId,
-      error: errorMessage4(err3)
-    });
-    return false;
+    return settleFailedSend(taskId, err3, sent, attempts, deps);
+  }
+}
+async function settleFailedSend(taskId, err3, sent, attempts, deps) {
+  if (sent && isShutdownRefusal(err3, deps)) {
+    deps.tracker.markSendFailed(taskId);
+    await attempts.release(taskId);
+    deps.carryToNextBoot(taskId);
+    return abandon(taskId, "shutdown", deps);
+  }
+  if (sent && err3 instanceof MessageAdmissionCancelledError) {
+    deps.tracker.markSendFailed(taskId);
+    await attempts.release(taskId);
+    return abandon(taskId, "cancelled_before_turn", deps);
+  }
+  if (sent) {
+    deps.tracker.markSendFailed(taskId);
+  } else if (err3 instanceof ResumeLostError) {
+    await attempts.release(taskId);
+    return abandon(taskId, err3.reason, deps);
+  } else {
+    deps.tracker.markDropped(taskId);
   }
+  deps.log({ event: "interrupted_resume_failed", taskId, error: errorMessage4(err3) });
+  return false;
 }
 function decideResumeExpiry(hold, ceilingConfirmed) {
   switch (hold) {
@@ -39983,14 +39998,15 @@ function resumeBlockerFor(sessionState, taskStatus) {
 }
 function createBootResumeRuntime(deps) {
   const snapshotBoundaryAt = Date.now();
-  const tracker = new BootResumeTracker(
-    (pending) => writeInterruptedTurnsSnapshot(
+  const tracker = new BootResumeTracker((pending) => {
+    if (disposed) return;
+    writeInterruptedTurnsSnapshot(
       deps.dataDir,
       deps.stopReason() === "quit" ? [] : pending,
       Date.now(),
       deps.log
-    )
-  );
+    );
+  });
   let pendingAtShutdown = null;
   const watched = /* @__PURE__ */ new Set();
   const queue = new BootSpawnQueue({
@@ -40005,6 +40021,7 @@ function createBootResumeRuntime(deps) {
   let handle = null;
   let disposed = false;
   let provisional = [];
+  let boundary = null;
   const overtake = (taskId, reason) => {
     watched.delete(taskId);
     pendingAtShutdown?.delete(taskId);
@@ -40060,6 +40077,7 @@ function createBootResumeRuntime(deps) {
     recordShutdownInterruptions(tasks) {
       unsubscribe();
       provisional = [];
+      boundary = tasks;
       writeStopList(tasks);
     },
     async schedule(input) {
@@ -40093,6 +40111,11 @@ function createBootResumeRuntime(deps) {
         resumeBlocker,
         /** Restore first, then recheck the slot: a restore that outlived it must not spawn. */
         automaticEpoch: (taskId) => taskManager.automaticEpoch(taskId),
+        carryToNextBoot: (taskId) => {
+          if (!pendingAtShutdown) return;
+          pendingAtShutdown.add(taskId);
+          writeStopList(boundary ?? provisional);
+        },
         sendResume: async (taskId, slot, automaticEpoch) => {
           await taskManager.restoreTask(taskId);
           slot.beginSpawn();
@@ -40113,6 +40136,7 @@ function createBootResumeRuntime(deps) {
       if (disposed) {
         pendingAtShutdown = /* @__PURE__ */ new Set([...pendingAtShutdown ?? [], ...tracker.pendingTaskIds()]);
         scheduled?.cancel();
+        writeStopList(boundary ?? provisional);
         return;
       }
       handle = scheduled;
@@ -67089,7 +67113,7 @@ var AgentWakeupService = class {
       await this.#deps.deliver(record2.taskId, message, ticket);
     } catch (err3) {
       ticket.release();
-      if (err3 instanceof MessageAdmissionCancelledError && !this.#disposed) {
+      if (isStopOfTask(err3) && !this.#disposed) {
         await this.#consumeStoppedFire(record2, now);
         return;
       }
@@ -67098,6 +67122,10 @@ var AgentWakeupService = class {
         this.#logDeferralOnce(record2, `boot_queue_slot_${err3.loss}`);
         return;
       }
+      if (err3 instanceof AutomaticTurnRefusedError) {
+        this.#logDeferralOnce(record2, "daemon_shutting_down");
+        return;
+      }
       this.#deps.log({
         event: "agent_wakeup_fire_failed",
         ...logFields(record2),
@@ -67196,6 +67224,10 @@ function matchesSelector(record2, selector) {
   if ("id" in selector) return record2.id === selector.id;
   return record2.key === selector.key;
 }
+function isStopOfTask(err3) {
+  if (err3 instanceof AutomaticTurnRefusedError) return err3.reason === "stopped";
+  return err3 instanceof MessageAdmissionCancelledError;
+}
 function deferralKey(record2) {
   return `${record2.id}:${record2.nextFireAt}`;
 }
@@ -112408,10 +112440,21 @@ function trackPlanFileCreation(content, onPlanFile) {
 }
 
 // src/services/task/orchestrator/task-unpushed-selection.ts
+var AUTOMATIC_MESSAGE_CORRELATION_PREFIX = "automsg_";
+function isAutomaticContent(content) {
+  const [first] = content;
+  if (content.length !== 1 || first?.type !== "text") return false;
+  return first.text === INTERRUPTED_TURN_RESUME_PROMPT || first.text.startsWith("<system-reminder>");
+}
+function dropAutomaticQueueEntries(entries) {
+  return entries.filter((entry) => !isAutomaticContent(entry.content));
+}
 function isUnconfirmedHuman(message, excludeCorrelationIds) {
   if (message.senderKind !== "human") return false;
   const { correlationId } = message;
   if (!correlationId) return false;
+  if (correlationId.startsWith(AUTOMATIC_MESSAGE_CORRELATION_PREFIX)) return false;
+  if (message.isSynthetic === true || isAutomaticContent(message.content)) return false;
   if (message.sdkUuid) return false;
   return !excludeCorrelationIds?.has(correlationId);
 }
@@ -114199,7 +114242,7 @@ var Task = class {
     const persistence = this.#deps.collabQueuePersistence;
     if (!persistence) return /* @__PURE__ */ new Set();
     const key = mainQueueKey(this.#deps.taskId);
-    const entries = await persistence.read(key);
+    const entries = dropAutomaticQueueEntries(await persistence.read(key));
     if (entries.length === 0) return /* @__PURE__ */ new Set();
     await this.#collabQueue.rehydrate(entries);
     const messages = await this.#deps.store.getMessages(this.#deps.channelId);
@@ -117201,7 +117244,8 @@ async function prepareUserMessageForDispatch(deps, task, message) {
     senderDisplayName,
     senderKind,
     correlationId,
-    isSynthetic
+    isSynthetic,
+    automatic: message.automaticEpoch !== null
   });
   onPersisted?.();
   let preparedContent = content;
@@ -117250,10 +117294,10 @@ function shouldSuppressDuplicate(taskStateStore, taskId, persisted, redriveDupli
   const spawnRequest = taskStateStore.getTaskSync(taskId)?.spawnRequest;
   return !(spawnRequest?.seedStatus === "pending" && spawnRequest.seedCorrelationId === persisted.correlationId);
 }
-function resolveCorrelationIdForEchoDedup(runtimeId, correlationId) {
+function resolveCorrelationIdForEchoDedup(runtimeId, correlationId, automatic) {
   if (correlationId !== void 0) return correlationId;
   if (runtimeId === AGENT_SYSTEM_CURSOR) return void 0;
-  return `taskmsg_${randomUUID30()}`;
+  return `${automatic ? AUTOMATIC_MESSAGE_CORRELATION_PREFIX : "taskmsg_"}${randomUUID30()}`;
 }
 function requireExistingMessage(args) {
   if (args.existingMessage) return args.existingMessage;
@@ -117263,7 +117307,8 @@ async function persistUserMessageAtChokepoint(args) {
   const effectiveSettings = { ...args.latestSettings, ...args.settings ?? {} };
   const persistedCorrelationId = resolveCorrelationIdForEchoDedup(
     args.runtimeId,
-    args.correlationId
+    args.correlationId,
+    args.automatic
   );
   const appendResult = await args.store.appendMessageDeduped(
     {
@@ -117450,6 +117495,7 @@ var TaskManager = class {
   #notifyAgentAction;
   #idleUnload;
   #unsubscribeAnnotations;
+  #unsubscribeTerminalMoves;
   constructor(deps) {
     this.#deps = deps;
     this.#notifyAgentAction = createAgentActionNotifier({
@@ -117472,6 +117518,10 @@ var TaskManager = class {
       ),
       deps.idleUnload
     );
+    this.#unsubscribeTerminalMoves = deps.taskStateStore.subscribe((event) => {
+      const terminal = event.kind !== "set" || event.data.archivedAt !== null || event.data.status === "completed" || event.data.status === "canceled";
+      if (terminal) this.#bumpAutomaticEpoch(event.id);
+    });
     this.#unsubscribeAnnotations = deps.annotationStore.subscribe((event) => {
       if (event.kind !== "set") return;
       if (!this.#idleUnload.hasNewNotifiableComment(event.id, event.data.records)) return;
@@ -118950,8 +119000,12 @@ var TaskManager = class {
   }
   #refuseStaleAutomatic(message) {
     if (message.automaticEpoch === null) return;
-    const stale = message.automaticEpoch < this.automaticEpoch(message.taskId);
-    if (stale || this.#automaticEpochs.shutDown) throw new AutomaticTurnRefusedError();
+    const record2 = this.#deps.taskStateStore.getTaskSync(message.taskId);
+    const terminal = record2 !== null && (record2.archivedAt != null || record2.status === "completed" || record2.status === "canceled");
+    if (terminal || message.automaticEpoch < this.automaticEpoch(message.taskId)) {
+      throw new AutomaticTurnRefusedError("stopped");
+    }
+    if (this.#automaticEpochs.shutDown) throw new AutomaticTurnRefusedError("shutdown");
   }
   /** Keeps the channel's persisted acknowledgement inside the TaskManager persistence boundary. */
   async handleChannelUserMessage(message) {
@@ -119287,6 +119341,7 @@ var TaskManager = class {
   }
   async disposeAll(opts) {
     this.#unsubscribeAnnotations();
+    this.#unsubscribeTerminalMoves();
     await this.#idleUnload.stop();
     this.#conversationMutations.cancelAllMessages();
     this.#deps.log({ event: "dispose_all_started", taskCount: this.#tasks.size });
@@ -125935,4 +125990,4 @@ export {
   decideWorkspaceScope,
   serve
 };
-//# sourceMappingURL=serve-4BO7AOJM.js.map
+//# sourceMappingURL=serve-FI5KNQA2.js.map