@schoolai/shipyard 3.3.1-rc.20260428.2 → 3.3.1

package/dist/index.js

@@ -111,7 +111,7 @@ async function handleSubcommand() {
     return true;
   }
   if (subcommand === "start") {
-    const { startCommand } = await import("./start-3CVST3BN.js");
+    const { startCommand } = await import("./start-OWA2D3PI.js");
     await startCommand();
     return true;
   }
@@ -128,7 +128,7 @@ async function main() {
   const args = parseCliArgs();
   if (args.serve) {
     await loadAuthFromConfig(env);
-    const { serve } = await import("./serve-6UUDZZYJ.js");
+    const { serve } = await import("./serve-K7MIPIVY.js");
     return serve({ isDev: env.SHIPYARD_DEV });
   }
   logger.error("Use `shipyard start` to run the daemon. Use --help for usage.");

package/dist/{serve-6UUDZZYJ.js → serve-K7MIPIVY.js}

@@ -43328,15 +43328,23 @@ function buildSetTaskCwdHandler(deps) {
   };
 }
 function buildEnvironmentChangedHandler(deps) {
-  const { daemon } = deps;
+  const { daemon, refreshCapabilities } = deps;
   let debounceTimer = null;
   return {
     onEnvironmentChanged: (cwd) => {
+      if (daemon.preWarmManager.cwd === cwd) {
+        if (debounceTimer) {
+          clearTimeout(debounceTimer);
+          debounceTimer = null;
+        }
+        return;
+      }
       daemon.taskManager.setWorkspaceRoot(cwd);
       if (debounceTimer) clearTimeout(debounceTimer);
       debounceTimer = setTimeout(() => {
         daemon.preWarmManager.kill();
         daemon.preWarmManager.start(cwd);
+        refreshCapabilities();
       }, 200);
     }
   };
@@ -45766,26 +45774,30 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
   const resourceUnsubs = /* @__PURE__ */ new Map();
   const commentCrud = wireCommentCrud(daemon, () => controlHandler, logAdapter);
   const todoHandlers = buildTodoHandlers(daemon, logAdapter);
+  let capRefreshGeneration = 0;
+  const refreshCapabilitiesAndPush = (failureEvent) => {
+    const gen = ++capRefreshGeneration;
+    daemon.userSettingsStore.getSettings().then(
+      (userSettings) => detectCapabilities(
+        deps?.tokenStore,
+        userSettings.preferredAnthropicAuth ?? void 0,
+        daemon.capabilities?.anthropicAuth
+      )
+    ).then((fresh) => {
+      if (gen !== capRefreshGeneration) return;
+      daemon.capabilities = fresh;
+      sendCapabilities(controlHandler);
+    }).catch((err) => {
+      logAdapter({
+        event: failureEvent,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
+  };
   const worktreeRunner = new WorktreeMachineRunner({
     io: defaultWorktreeIO,
     sendControl: (msg) => controlHandler.sendControl(msg),
-    refreshCapabilities: () => {
-      daemon.userSettingsStore.getSettings().then(
-        (userSettings) => detectCapabilities(
-          deps?.tokenStore,
-          userSettings.preferredAnthropicAuth ?? void 0,
-          daemon.capabilities?.anthropicAuth
-        )
-      ).then((fresh) => {
-        daemon.capabilities = fresh;
-        sendCapabilities(controlHandler);
-      }).catch((err) => {
-        logAdapter({
-          event: "capability_refresh_after_worktree_failed",
-          error: err instanceof Error ? err.message : String(err)
-        });
-      });
-    },
+    refreshCapabilities: () => refreshCapabilitiesAndPush("capability_refresh_after_worktree_failed"),
     log: logAdapter
   });
   const lazyInfraDeps = {
@@ -45797,6 +45809,7 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
     tokenStore: deps?.tokenStore,
     logAdapter,
     sendCapabilities,
+    refreshCapabilities: () => refreshCapabilitiesAndPush("capability_refresh_after_env_changed_failed"),
     worktreeRunner
   };
   const worktreeHandlers = buildWorktreeHandlers(lazyInfraDeps);
@@ -48200,9 +48213,10 @@ function handleFileIOChannel(initialCwd, send, log, deps) {
         respondError(requestId, "Path is not a directory");
         return;
       }
+      respond({ type: "set_cwd_ack", requestId, canonical });
+      if (canonical === cwd) return;
       cwd = canonical;
       log({ event: "file_io_cwd_changed", cwd: canonical });
-      respond({ type: "set_cwd_ack", requestId, canonical });
       for (const listener of cwdChangeListeners) {
         listener(canonical);
       }
@@ -49076,7 +49090,7 @@ function createPtyManager() {
     }
     log.info({ shell, cwd: options.cwd, cols, rows }, "Spawning PTY");
     try {
-      process2 = pty.spawn(shell, ["--login"], {
+      process2 = pty.spawn(shell, [], {
         name: "xterm-256color",
         cols,
         rows,
@@ -49196,10 +49210,8 @@ function createPtyManager() {
 
 // src/services/terminal-handler.ts
 var MAX_PTYS_DEFAULT = 20;
-var CWD_TIMEOUT_MS = 5e3;
 function handleTerminalChannel(taskId, terminalId, cwd, send, log, deps) {
   const maxPtys = deps.maxPtys ?? MAX_PTYS_DEFAULT;
-  let cwdTimer = null;
   let disposed = false;
   function sendControl(msg) {
     if (disposed) return;
@@ -49277,6 +49289,7 @@ function handleTerminalChannel(taskId, terminalId, cwd, send, log, deps) {
     });
     pty2.setExitSink((exitCode3) => {
       sendControl({ type: "exited", exitCode: exitCode3 });
+      log({ event: "terminal_exited", taskId, terminalId, exitCode: exitCode3 });
     });
     log({ event: "terminal_reattached", taskId, terminalId, pid: pty2.pid });
   }
@@ -49292,25 +49305,7 @@ function handleTerminalChannel(taskId, terminalId, cwd, send, log, deps) {
     }
     return spawnPty(spawnCwd);
   }
-  let ptyRef = null;
-  let cwdReceived = false;
-  function cancelCwdTimer() {
-    if (cwdTimer) {
-      clearTimeout(cwdTimer);
-      cwdTimer = null;
-    }
-  }
-  function forceSpawn() {
-    cwdReceived = true;
-    cancelCwdTimer();
-    ptyRef = ensurePty(cwd);
-  }
-  cwdTimer = setTimeout(() => {
-    cwdTimer = null;
-    if (!cwdReceived && !disposed) {
-      ptyRef = ensurePty(cwd);
-    }
-  }, CWD_TIMEOUT_MS);
+  let ptyRef = ensurePty(cwd);
   function handleControl(payload) {
     const parsed = TerminalControlMessageSchema.safeParse(JSON.parse(payload));
     if (!parsed.success) {
@@ -49320,8 +49315,6 @@ function handleTerminalChannel(taskId, terminalId, cwd, send, log, deps) {
     const msg = parsed.data;
     switch (msg.type) {
       case "cwd":
-        cwdReceived = true;
-        cancelCwdTimer();
         if (!ptyRef) ptyRef = ensurePty(msg.path);
         return;
       case "resize":
@@ -49344,15 +49337,11 @@ function handleTerminalChannel(taskId, terminalId, cwd, send, log, deps) {
       }
       return;
     }
-    if (!ptyRef) forceSpawn();
+    if (!ptyRef) ptyRef = ensurePty(cwd);
     if (ptyRef?.alive) ptyRef.write(data);
   }
   function dispose() {
     disposed = true;
-    if (cwdTimer) {
-      clearTimeout(cwdTimer);
-      cwdTimer = null;
-    }
     if (ptyRef) {
       ptyRef.setDataSink(null);
       ptyRef.setExitSink(null);
@@ -100457,6 +100446,26 @@ function buildJsonlConversationStore(dataDir) {
     });
     return [...fresh];
   }
+  async function refreshCacheAfterAppend(channelId, appended) {
+    const hit = readCache.get(channelId);
+    if (!hit) return;
+    try {
+      const s2 = await stat13(channelPath(channelId));
+      hit.messages.push(appended);
+      hit.size = s2.size;
+      hit.mtimeMs = s2.mtimeMs;
+    } catch (err) {
+      if (isEnoent(err)) {
+        readCache.delete(channelId);
+        return;
+      }
+      logPerf({
+        event: "perf_jsonl_cache_refresh_stat_failed",
+        channelId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
   function contentFingerprint(message) {
     const texts = message.content.filter((b2) => b2.type === "text").map((b2) => b2.type === "text" ? b2.text : "").join("\0");
     return `${message.participantId}
${texts}`;
@@ -100594,7 +100603,7 @@ function buildJsonlConversationStore(dataDir) {
       const prev = channelQueues.get(message.channelId) ?? Promise.resolve();
       const next = prev.then(async () => {
         await ensureDir();
-        const existing = await readLines(message.channelId);
+        const existing = await readLinesCached(message.channelId);
         const currentSeq = seqCounters.get(message.channelId);
         const decision = classifyDedupResult(
           existing,
@@ -100616,7 +100625,11 @@ function buildJsonlConversationStore(dataDir) {
         const line = JSON.stringify(rest);
         await appendFile2(channelPath(message.channelId), `${line}
 `, "utf-8");
-        readCache.delete(message.channelId);
+        await refreshCacheAfterAppend(message.channelId, {
+          ...rest,
+          channelId: message.channelId,
+          seqNo: decision.seqNo
+        });
         resolveResult({ seqNo: decision.seqNo, isDuplicate: false, dedupKey: null });
       }).catch((err) => {
         readCache.delete(message.channelId);
@@ -103654,6 +103667,13 @@ var Thread = class {
   #sendControlMessage;
   #streamDeltaSinks = /* @__PURE__ */ new Set();
   #latestSettings = {};
+  /**
+   * Last values pushed to the live subprocess. Reset to undefined whenever
+   * a fresh subprocess is attached (settings get applied via spawn options
+   * instead). Lets `#applySettingsToSubprocess` skip per-flush IPC roundtrips
+   * when nothing has changed since the previous flush.
+   */
+  #appliedToSubprocess = {};
   #agentParticipantId = PENDING_AGENT_PARTICIPANT_ID;
   #ownSessionId = null;
   /** Fork retry state */
@@ -103720,6 +103740,7 @@ var Thread = class {
       if (config2.onCwdChanged) {
         this.#subprocess.setOnCwdChanged(config2.onCwdChanged);
       }
+      this.#seedAppliedFromSpawnSettings();
     }
     const warmState = "warm_idle";
     const coldState = "cold_idle";
@@ -103954,6 +103975,7 @@ var Thread = class {
     this.#subprocess?.setOnCwdChanged(null);
     this.#subprocess?.close();
     this.#subprocess = null;
+    this.#appliedToSubprocess = {};
   }
   setControlChannelSend(send) {
     this.#sendControlMessage = send;
@@ -104138,6 +104160,7 @@ ${conversationReplay}` : conversationReplay;
         this.#config.mode,
         this.#config.onCwdChanged
       );
+      this.#seedAppliedFromSpawnSettings();
     };
     doSpawn().catch((err) => {
       const msg = err instanceof Error ? err.message : String(err);
@@ -104149,6 +104172,20 @@ ${conversationReplay}` : conversationReplay;
       this.#manager.notifySpawnFailed(msg, this.#lastSpawnInitialContent ?? void 0);
     });
   }
+  /**
+   * Subprocess spawn applies the latest settings via spawn options. Mirror
+   * those into `#appliedToSubprocess` so the first flush after spawn doesn't
+   * re-issue equivalent IPC roundtrips.
+   */
+  #seedAppliedFromSpawnSettings() {
+    const s2 = this.#latestSettings;
+    this.#appliedToSubprocess = {
+      permissionMode: s2.permissionMode,
+      model: s2.model,
+      reasoningEffort: s2.reasoningEffort,
+      fastMode: s2.fastMode
+    };
+  }
   /**
    * Flush #latestSettings to the running subprocess after spawn. Each setting
    * is awaited independently and errors are logged but don't abort the flush —
@@ -104163,23 +104200,28 @@ ${conversationReplay}` : conversationReplay;
     if (!this.#subprocess) return;
     const subprocess = this.#subprocess;
     const settings = this.#latestSettings;
+    const applied = this.#appliedToSubprocess;
     const permissionMode = settings.permissionMode;
-    if (permissionMode !== void 0) {
+    if (permissionMode !== void 0 && permissionMode !== applied.permissionMode) {
       await this.#tryFlush("permission_mode", () => subprocess.setPermissionMode(permissionMode));
+      applied.permissionMode = permissionMode;
     }
     const model = settings.model;
-    if (model !== void 0) {
+    if (model !== void 0 && model !== applied.model) {
       await this.#tryFlush("model", () => subprocess.setModel(model));
+      applied.model = model;
     }
-    if (settings.reasoningEffort !== void 0) {
+    if (settings.reasoningEffort !== void 0 && settings.reasoningEffort !== applied.reasoningEffort) {
       const patch = translateEffortToFlagSettings(settings.reasoningEffort);
       if (patch !== null) {
         await this.#tryFlush("effort", () => subprocess.applyFlagSettings(patch));
       }
+      applied.reasoningEffort = settings.reasoningEffort;
     }
-    if (settings.fastMode !== void 0) {
+    if (settings.fastMode !== void 0 && settings.fastMode !== applied.fastMode) {
       const fastMode = settings.fastMode;
       await this.#tryFlush("fast_mode", () => subprocess.applyFlagSettings({ fastMode }));
+      applied.fastMode = fastMode;
     }
   }
   async #tryFlush(kind, fn) {
@@ -104235,10 +104277,12 @@ ${conversationReplay}` : conversationReplay;
     this.#subprocess?.setOnCwdChanged(null);
     this.#subprocess?.close();
     this.#subprocess = null;
+    this.#appliedToSubprocess = {};
   }
   #handleForceKill() {
     this.#subprocess?.forceKill();
     this.#subprocess = null;
+    this.#appliedToSubprocess = {};
   }
   /** ------------------------------------------------------------------ */
   /** SDK error retry logic                                              */
@@ -117850,4 +117894,4 @@ export {
   decideWorkspaceScope,
   serve
 };
-//# sourceMappingURL=serve-6UUDZZYJ.js.map
+//# sourceMappingURL=serve-K7MIPIVY.js.map