open-walnut 0.4.0 → 0.4.1

package/dist/web/server.js

@@ -10199,7 +10199,25 @@ function reapSession(sid, code, reason) {
   let jsonlAgeMs = null;
   try { jsonlAgeMs = Date.now() - fs.statSync(session.jsonlPath).mtimeMs; } catch {}
   const cleanExit = isTurnCompleteExit(session.jsonlPath);
-  if (code !== 0 && cleanExit) {
+  // An INTENTIONAL daemon-initiated reclamation is not a failure, and the JSONL
+  // tail cannot tell us it happened. The idle scanner stamps idleReclaimAt
+  // before it signals; the death then lands here through whichever path notices
+  // it (usually orphan-poll ESRCH \u2192 code -1). Verified production case: the last
+  // line was a control_response (the reply to a Walnut-issued control request \u2014
+  // a routine shape), so isTurnCompleteExit said false, exitCode stayed -1, and
+  // the projection painted a red "Error" over a healthy, fully resumable session
+  // we reclaimed on purpose. Checked FIRST and unconditionally: the flag carries
+  // information the tail does not contain, which is why isTurnCompleteExit is
+  // left alone. Keep in sync with daemon-core.ts reapSession.
+  const intentionalReclaim = session.idleReclaimAt != null;
+  if (intentionalReclaim && code !== 0) {
+    logMsg('info', 'reapSession: intentional idle reclamation, normalizing exit code', {
+      sid, pid: session.pid, originalCode: code, originalReason: reason,
+      jsonlAgeMs, cleanExit, idleReclaimAt: session.idleReclaimAt,
+    });
+    code = 0;
+    reason = reason + '+intentional-idle-reclaim';
+  } else if (code !== 0 && cleanExit) {
     logMsg('info', 'reapSession: turn-complete detected, normalizing exit code', {
       sid, pid: session.pid, originalCode: code, originalReason: reason, jsonlAgeMs,
     });
@@ -15964,6 +15982,14 @@ function scanIdleSessions() {
       }
       const idleMinutes = Math.round(idleMs / 60000);
       logMsg('warn', 'idle scan: killing idle session (no subscribers, no output)', { sid, pid, idleMinutes, protectedBy: prot.source, thresholdMs: prot.killMs, detail: prot.detail });
+      // Record the intent BEFORE signalling: the reap arrives asynchronously
+      // (the orphan poll sees ESRCH and reports 'orphan-poll-dead', code -1), so
+      // by then nothing remembers that WE asked for this. Without the stamp
+      // reapSession can only consult the JSONL tail, which says "not a clean turn
+      // end" for any session whose last line isn't a type:result \u2014 and the
+      // projection then shows a red Error for our own routine reclamation.
+      // Keep in sync with daemon-standalone.ts scanIdleSessions.
+      session.idleReclaimAt = now;
       killSessionProcessGroup(pid, sid);
     }
   }
@@ -16647,7 +16673,20 @@ function createDaemonCore(deps) {
       jsonlAgeMs = clock() - fs114.statSync(session2.jsonlPath).mtimeMs;
     } catch {
     }
-    if (cleanExit && code !== 0) {
+    const intentionalReclaim = session2.idleReclaimAt != null;
+    if (intentionalReclaim && code !== 0) {
+      logger2("info", "reapSession: intentional idle reclamation, normalizing exit code", {
+        sid,
+        pid: session2.pid,
+        originalCode: code,
+        originalReason: reason,
+        jsonlAgeMs,
+        cleanExit,
+        idleReclaimAt: session2.idleReclaimAt
+      });
+      code = 0;
+      reason = reason + "+intentional-idle-reclaim";
+    } else if (cleanExit && code !== 0) {
       logger2("info", "reapSession: turn-complete detected, normalizing exit code", {
         sid,
         pid: session2.pid,
@@ -18118,6 +18157,22 @@ var init_local_daemon = __esm({
 });
 
 // src/core/session-error-kind.ts
+var session_error_kind_exports = {};
+__export(session_error_kind_exports, {
+  INFRA_STATUS_REASONS: () => INFRA_STATUS_REASONS,
+  RESCUABLE_STOPPED_WINDOW_MS: () => RESCUABLE_STOPPED_WINDOW_MS,
+  TERMINAL_STATUS_REASONS: () => TERMINAL_STATUS_REASONS,
+  assertsHostUnreachable: () => assertsHostUnreachable,
+  classifySessionError: () => classifySessionError,
+  classifyStatusReasonKind: () => classifyStatusReasonKind,
+  isInfraSessionError: () => isInfraSessionError,
+  isRecoverableSessionError: () => isRecoverableSessionError,
+  isRescuableStoppedRecord: () => isRescuableStoppedRecord
+});
+function assertsHostUnreachable(record) {
+  if (!record.errorMessage) return false;
+  return typeof record.status_reason === "string" && REACHABILITY_CLAIM_REASONS.has(record.status_reason);
+}
 function classifyStatusReasonKind(reason) {
   if (typeof reason !== "string") return void 0;
   if (INFRA_STATUS_REASONS.has(reason)) return "infra";
@@ -18146,7 +18201,7 @@ function isRescuableStoppedRecord(record, nowMs = Date.now()) {
   if (!Number.isFinite(changedAt)) return false;
   return nowMs - changedAt <= RESCUABLE_STOPPED_WINDOW_MS;
 }
-var INFRA_STATUS_REASONS, TERMINAL_STATUS_REASONS, INFRA_TEXT_SIGNATURES, RESCUABLE_STOPPED_WINDOW_MS;
+var INFRA_STATUS_REASONS, TERMINAL_STATUS_REASONS, INFRA_TEXT_SIGNATURES, REACHABILITY_CLAIM_REASONS, RESCUABLE_STOPPED_WINDOW_MS;
 var init_session_error_kind = __esm({
   "src/core/session-error-kind.ts"() {
     "use strict";
@@ -18190,6 +18245,9 @@ var init_session_error_kind = __esm({
       "ssh tunnel",
       "broken pipe"
     ];
+    REACHABILITY_CLAIM_REASONS = /* @__PURE__ */ new Set([
+      "remote_unreachable"
+    ]);
     RESCUABLE_STOPPED_WINDOW_MS = 24 * 60 * 60 * 1e3;
   }
 });
@@ -68462,8 +68520,22 @@ var init_token_truth = __esm({
 });
 
 // src/utils/image-compress.ts
-import sharp from "sharp";
+async function loadSharp() {
+  sharpLoad ??= import("sharp").then(
+    (m6) => m6.default ?? m6,
+    (err2) => {
+      log.agent.warn("sharp is not installed; images are sent uncompressed", {
+        error: err2 instanceof Error ? err2.message : String(err2),
+        fix: "a machine with glibc 2.28+ installs sharp prebuilt; otherwise install libvips and re-run npm install"
+      });
+      return null;
+    }
+  );
+  return sharpLoad;
+}
 async function clampImageDimensions(buffer2, mimeType) {
+  const sharp = await loadSharp();
+  if (!sharp) return { buffer: buffer2, mimeType };
   try {
     const meta = await sharp(buffer2).metadata();
     const longest = Math.max(meta.width ?? 0, meta.height ?? 0);
@@ -68485,6 +68557,8 @@ async function compressForApi(inputBuffer, inputMimeType) {
   if (buffer2.toString("base64").length <= MAX_BASE64_BYTES) {
     return { buffer: buffer2, mimeType };
   }
+  const sharp = await loadSharp();
+  if (!sharp) return { buffer: buffer2, mimeType };
   try {
     if (mimeType === "image/gif") {
       const webp = await sharp(buffer2, { animated: true }).webp({ quality: 80 }).toBuffer();
@@ -68522,10 +68596,11 @@ async function compressForApi(inputBuffer, inputMimeType) {
     return { buffer: buffer2, mimeType };
   }
 }
-var MAX_BASE64_BYTES, MAX_IMAGE_DIMENSION;
+var sharpLoad, MAX_BASE64_BYTES, MAX_IMAGE_DIMENSION;
 var init_image_compress = __esm({
   "src/utils/image-compress.ts"() {
     "use strict";
+    init_logging();
     MAX_BASE64_BYTES = 5e6;
     MAX_IMAGE_DIMENSION = 1568;
   }
@@ -71516,9 +71591,20 @@ async function applySnapshot(sessionId, snapshot2, source) {
     updates.errorKind = void 0;
     clearSuppressedErrorReason(sessionId);
   } else {
+    let droppedDisproven = false;
+    if (assertsHostUnreachable(record)) {
+      updates.errorMessage = void 0;
+      droppedDisproven = true;
+      log.session.info("snapshot projection dropped disproven unreachability diagnosis", {
+        sessionId,
+        priorReason: record.status_reason ?? null,
+        projected,
+        source
+      });
+    }
     const stashed = takeSuppressedErrorReason(sessionId);
     if (stashed) {
-      if (!record.errorMessage && stashed.message) updates.errorMessage = stashed.message;
+      if ((!record.errorMessage || droppedDisproven) && stashed.message) updates.errorMessage = stashed.message;
       if (!record.errorKind && stashed.kind) updates.errorKind = stashed.kind;
       log.session.info("snapshot projection adopted suppressed error reason", {
         sessionId,
@@ -71571,6 +71657,7 @@ var init_session_snapshot_apply = __esm({
     "use strict";
     init_logging();
     init_session_snapshot_gate();
+    init_session_error_kind();
     init_engine_registry();
     init_session_snapshot_gate();
     TERMINAL = /* @__PURE__ */ new Set(["stopped", "error"]);
@@ -74185,9 +74272,15 @@ var init_acp_session = __esm({
       }
       async resolveArtifacts() {
         if (this.cfg.artifacts) return this.cfg.artifacts;
-        return resolveAcpArtifacts(this.engineId, {
+        const artifacts = resolveAcpArtifacts(this.engineId, {
           configuredAdapterCmd: await this.resolveConfiguredAdapterCmd()
         });
+        if (!fsModule.existsSync(artifacts.workerCmd[1])) {
+          throw new Error(
+            `Engine '${this.engineId}' runs on the ACP worker, which is not built (${artifacts.workerCmd[1]}). Install Bun (https://bun.sh) and run \`npm run build:daemon\`, or install Walnut from npm, which ships it.`
+          );
+        }
+        return artifacts;
       }
       async establishProviderSession() {
         await this.seedReplayCursor();
@@ -77724,6 +77817,7 @@ __export(session_lifecycle_exports, {
   persistSessionModeChange: () => persistSessionModeChange,
   readProviderSessionHistory: () => readProviderSessionHistory,
   readSessionRichHistory: () => readSessionRichHistory,
+  recheckSession: () => recheckSession,
   respondSessionPermission: () => respondSessionPermission,
   restartSession: () => restartSession,
   retrySession: () => retrySession,
@@ -78061,7 +78155,7 @@ async function retrySession(sessionId) {
       return { status: "reconnected", sessionId };
     }
     if (await resumeConversationExists(record)) {
-      const { sendMessageToSession: sendMessageToSession2, getQueue: getQueue2, unparkMessage: unparkMessage2 } = await Promise.resolve().then(() => (init_session_message_queue(), session_message_queue_exports));
+      const { getQueue: getQueue2, unparkMessage: unparkMessage2 } = await Promise.resolve().then(() => (init_session_message_queue(), session_message_queue_exports));
       const pendingMsgs = await getQueue2(sessionId);
       for (const parked of pendingMsgs.filter((m6) => m6.status === "parked")) {
         await unparkMessage2(sessionId, parked.id);
@@ -78071,9 +78165,22 @@ async function retrySession(sessionId) {
         log.session.info("session retry: re-processing pending queue messages", { sessionId, taskId: record.taskId, count: pendingMsgs.length });
         return { status: "resuming", sessionId, restoredMessages: pendingMsgs.length };
       }
-      await sendMessageToSession2(sessionId, "continue", { source: "retry", taskId: record.taskId });
-      log.session.info("session retry: resuming via --resume (no pending messages)", { sessionId, taskId: record.taskId });
-      return { status: "resuming", sessionId };
+      const relabelled = await updateSessionRecord2(sessionId, {
+        process_status: "stopped",
+        errorMessage: void 0,
+        errorKind: void 0,
+        activity: void 0,
+        last_status_change: (/* @__PURE__ */ new Date()).toISOString(),
+        status_reason: "retry_reconnect",
+        status_changed_by: "user"
+      });
+      emitSessionStatusChanged2(relabelled, {}, ["*"]);
+      log.session.info("session retry: reconnected \u2014 conversation preserved, no message sent", {
+        sessionId,
+        taskId: record.taskId,
+        host: record.host ?? "__local__"
+      });
+      return { status: "resumable", sessionId };
     }
     log.session.warn("session retry: conversation never persisted \u2014 starting fresh instead of --resume", {
       sessionId,
@@ -78131,6 +78238,91 @@ async function retrySession(sessionId) {
   });
   return { status: "pending", taskId: task.id, oldSessionId: sessionId };
 }
+async function withDeadline(p6, ms) {
+  let timer3;
+  try {
+    return await Promise.race([
+      p6,
+      new Promise((resolve) => {
+        timer3 = setTimeout(() => resolve(RECHECK_TIMED_OUT), ms);
+        if (timer3 && typeof timer3 === "object" && "unref" in timer3) timer3.unref();
+      })
+    ]);
+  } finally {
+    if (timer3) clearTimeout(timer3);
+  }
+}
+async function recheckSession(sessionId) {
+  const { getSessionByClaudeId: getSessionByClaudeId2 } = await Promise.resolve().then(() => (init_session_tracker(), session_tracker_exports));
+  const record = await getSessionByClaudeId2(sessionId);
+  if (!record) throw new SessionControlError("Session not found", 404);
+  const hostKey2 = record.host ?? "__local__";
+  const { classifySessionError: classifySessionError2 } = await Promise.resolve().then(() => (init_session_error_kind(), session_error_kind_exports));
+  const kind = classifySessionError2(record);
+  const base = { sessionId, processStatus: record.process_status, infraClaim: kind === "infra" };
+  const { isDaemonConnected: isDaemonConnected2, getPooledSnapshotConnection: getPooledSnapshotConnection2 } = await Promise.resolve().then(() => (init_daemon_connection(), daemon_connection_exports));
+  const reachable = isDaemonConnected2(hostKey2);
+  if (kind === "terminal") return { ...base, checked: false, reachable, reason: "terminal_error" };
+  if (record.archived) return { ...base, checked: false, reachable, reason: "archived" };
+  const conn = getPooledSnapshotConnection2(record.host);
+  if (!conn) {
+    log.session.info("session recheck: no pooled snapshot connection \u2014 nothing to ask", {
+      sessionId,
+      host: hostKey2,
+      reachable
+    });
+    return { ...base, checked: false, reachable, reason: "no_pooled_connection" };
+  }
+  let raced;
+  try {
+    raced = await withDeadline(
+      conn.send("getState", { sid: sessionId }, RECHECK_RPC_TIMEOUT_MS),
+      RECHECK_RPC_TIMEOUT_MS
+    );
+  } catch (err2) {
+    log.session.info("session recheck: getState failed", {
+      sessionId,
+      host: hostKey2,
+      error: err2 instanceof Error ? err2.message : String(err2)
+    });
+    return { ...base, checked: false, reachable, reason: "rpc_failed" };
+  }
+  if (raced === RECHECK_TIMED_OUT) {
+    log.session.warn("session recheck: getState timed out", {
+      sessionId,
+      host: hostKey2,
+      timeoutMs: RECHECK_RPC_TIMEOUT_MS
+    });
+    return { ...base, checked: false, reachable, reason: "timeout" };
+  }
+  const snapshot2 = raced?.ok ? raced.snapshot : void 0;
+  if (!snapshot2) {
+    return { ...base, checked: false, reachable: true, reason: "no_snapshot" };
+  }
+  const { applySnapshot: applySnapshot2 } = await Promise.resolve().then(() => (init_session_snapshot_apply(), session_snapshot_apply_exports));
+  const outcome = await applySnapshot2(sessionId, snapshot2, "recheck-open");
+  const after = await getSessionByClaudeId2(sessionId);
+  const processStatus = after?.process_status ?? record.process_status;
+  log.session.info("session recheck: reconciled against host", {
+    sessionId,
+    host: hostKey2,
+    previous: record.process_status,
+    processStatus,
+    cliState: snapshot2.cliState,
+    applyOutcome: outcome.outcome
+  });
+  return {
+    sessionId,
+    checked: true,
+    reachable: true,
+    alive: snapshot2.cliState !== "dead",
+    processStatus,
+    // Re-classify against the CURRENT record: a converged row may no longer
+    // carry the claim, and the client uses this to decide whether the sentence
+    // on screen is still true.
+    infraClaim: classifySessionError2(after ?? record) === "infra"
+  };
+}
 async function respondSessionPermission(sessionId, requestId, allow, denyMessage, optionId, answers) {
   if (typeof requestId !== "string" || !requestId || typeof allow !== "boolean") {
     throw new SessionControlError("requestId (string) and allow (boolean) are required", 400);
@@ -78424,7 +78616,7 @@ async function readSessionRichHistory(sessionId, tail) {
     ...historyWindowed ? { windowed: true } : {}
   };
 }
-var CLAUDE_SESSION_MODES, MAX_PINNED_MESSAGES, MAX_PIN_LABEL_CHARS, MAX_PIN_ID_CHARS, GIT_BASES, MAX_FORK_DEPTH, HISTORY_STARTUP_GRACE_MS;
+var CLAUDE_SESSION_MODES, MAX_PINNED_MESSAGES, MAX_PIN_LABEL_CHARS, MAX_PIN_ID_CHARS, RECHECK_RPC_TIMEOUT_MS, RECHECK_TIMED_OUT, GIT_BASES, MAX_FORK_DEPTH, HISTORY_STARTUP_GRACE_MS;
 var init_session_lifecycle = __esm({
   "src/core/sessions/session-lifecycle.ts"() {
     "use strict";
@@ -78438,6 +78630,8 @@ var init_session_lifecycle = __esm({
     MAX_PINNED_MESSAGES = 200;
     MAX_PIN_LABEL_CHARS = 300;
     MAX_PIN_ID_CHARS = 200;
+    RECHECK_RPC_TIMEOUT_MS = 5e3;
+    RECHECK_TIMED_OUT = /* @__PURE__ */ Symbol("recheck-timeout");
     GIT_BASES = /* @__PURE__ */ new Set(["uncommitted", "previous", "remote"]);
     MAX_FORK_DEPTH = 5;
     HISTORY_STARTUP_GRACE_MS = 2 * 60 * 1e3;
@@ -87820,7 +88014,7 @@ function isRevealSecretPath(resolved) {
   ];
   return denied.some((d8) => resolved === d8 || resolved.startsWith(d8 + path70.sep)) || /(^|\/)config\.ya?ml$/.test(resolved);
 }
-var filesRouter, MAX_ENTRIES2, REMOTE_TIMEOUT_MS3, REMOTE_RESOLVE_BUDGET_MS, FilesOpError, MAX_UPWARD_LEVELS2, MAX_DOWNWARD_DEPTH, REFERENCE_SEARCH_BUDGET_MS, SYMBOL_RE2, REVEAL_APP_DENY_EXTS;
+var filesRouter, MAX_ENTRIES2, REMOTE_TIMEOUT_MS3, REMOTE_RESOLVE_BUDGET_MS, FilesOpError, MAX_UPWARD_LEVELS2, MAX_DOWNWARD_DEPTH, REFERENCE_SEARCH_BUDGET_MS, SYMBOL_RE2, LIST_MANY_MAX_PATHS, LIST_MANY_CONCURRENCY, LIST_MANY_DEADLINE_MS, REVEAL_APP_DENY_EXTS;
 var init_files2 = __esm({
   "src/web/routes/files.ts"() {
     "use strict";
@@ -87953,6 +88147,54 @@ var init_files2 = __esm({
         next(err2);
       }
     });
+    LIST_MANY_MAX_PATHS = 64;
+    LIST_MANY_CONCURRENCY = 8;
+    LIST_MANY_DEADLINE_MS = 8e3;
+    filesRouter.post("/list-many", async (req, res, next) => {
+      try {
+        const body3 = req.body ?? {};
+        const raw = Array.isArray(body3.paths) ? body3.paths : null;
+        if (!raw) {
+          res.status(400).json({ error: "paths (string[]) is required" });
+          return;
+        }
+        const host = typeof body3.host === "string" && body3.host ? body3.host : void 0;
+        const showHidden = body3.showHidden === true || body3.showHidden === "1";
+        const paths = [...new Set(
+          raw.filter((p6) => typeof p6 === "string" && !!p6)
+        )];
+        const truncated = paths.length > LIST_MANY_MAX_PATHS;
+        const wanted = paths.slice(0, LIST_MANY_MAX_PATHS);
+        const deadline4 = Date.now() + LIST_MANY_DEADLINE_MS;
+        const listings = [];
+        let timedOut = false;
+        let next_ = 0;
+        const worker = async () => {
+          for (; ; ) {
+            const i8 = next_++;
+            if (i8 >= wanted.length) return;
+            if (Date.now() >= deadline4) {
+              timedOut = true;
+              return;
+            }
+            const dirPath = wanted[i8];
+            try {
+              listings.push(await listSessionFiles(dirPath, host, showHidden));
+            } catch (err2) {
+              listings.push({ path: dirPath, error: err2 instanceof Error ? err2.message : String(err2) });
+            }
+          }
+        };
+        await Promise.all(Array.from({ length: Math.min(LIST_MANY_CONCURRENCY, wanted.length) }, worker));
+        res.json({ listings, truncated, timedOut });
+      } catch (err2) {
+        if (err2 instanceof FilesOpError) {
+          res.status(err2.statusCode).json({ error: err2.message });
+          return;
+        }
+        next(err2);
+      }
+    });
     REVEAL_APP_DENY_EXTS = /* @__PURE__ */ new Set([
       "command",
       "sh",
@@ -115976,6 +116218,11 @@ async function handleSessionControlRelay(action, sessionId, params) {
         result = await retrySession2(sessionId);
         break;
       }
+      case "recheck": {
+        const { recheckSession: recheckSession2 } = await Promise.resolve().then(() => (init_session_lifecycle(), session_lifecycle_exports));
+        result = await recheckSession2(sessionId);
+        break;
+      }
       case "permission": {
         const { respondSessionPermission: respondSessionPermission2 } = await Promise.resolve().then(() => (init_session_lifecycle(), session_lifecycle_exports));
         result = await respondSessionPermission2(sessionId, p6.requestId, p6.allow, p6.message, p6.optionId, p6.answers);
@@ -153537,6 +153784,19 @@ var init_sessions = __esm({
         next(err2);
       }
     });
+    sessionsRouter.post("/:sessionId/recheck", async (req, res, next) => {
+      try {
+        const sessionId = req.params.sessionId;
+        const result = await recheckSession(sessionId);
+        res.json(result);
+      } catch (err2) {
+        if (err2 instanceof SessionControlError) {
+          res.status(err2.statusCode).json({ error: err2.message });
+          return;
+        }
+        next(err2);
+      }
+    });
     sessionsRouter.post("/:sessionId/restart", async (req, res, next) => {
       const sessionId = req.params.sessionId;
       const startedAt = Date.now();
@@ -155260,9 +155520,13 @@ var init_credential_verify = __esm({
 var config_exports = {};
 __export(config_exports, {
   buildProvidersPayload: () => buildProvidersPayload,
-  configRouter: () => configRouter
+  configRouter: () => configRouter,
+  setStaticRootReporter: () => setStaticRootReporter
 });
 import { Router as Router20 } from "express";
+function setStaticRootReporter(fn) {
+  staticRootReporter = fn;
+}
 async function fetchOllamaModels(baseUrl) {
   if (Date.now() - _ollamaCache.ts < OLLAMA_CACHE_TTL) return _ollamaCache.models;
   const url = (baseUrl ?? DEFAULT_BASE_URLS["ollama"] ?? "http://localhost:11434") + "/api/tags";
@@ -155395,7 +155659,7 @@ async function buildProvidersPayload() {
   }
   return { providers };
 }
-var configRouter, _ollamaCache, OLLAMA_CACHE_TTL;
+var configRouter, staticRootReporter, _ollamaCache, OLLAMA_CACHE_TTL;
 var init_config11 = __esm({
   "src/web/routes/config.ts"() {
     "use strict";
@@ -155410,6 +155674,7 @@ var init_config11 = __esm({
     init_defaults();
     init_config_redact();
     configRouter = Router20();
+    staticRootReporter = null;
     configRouter.get("/", async (_req, res, next) => {
       try {
         const config = await getConfig();
@@ -155436,7 +155701,8 @@ var init_config11 = __esm({
           remoteIdUniquenessGaps = getExtIndexUniquenessGaps2();
         } catch {
         }
-        res.json({ config: CLOUD_MODE ? redactConfig(config) : config, envTokenHint, installDir: CLOUD_MODE ? null : WALNUT_INSTALL_DIR, notesDir: CLOUD_MODE ? null : NOTES_DIR, processNice, memory, canRevealLocalFiles, remoteIdUniquenessGaps, cloud: CLOUD_MODE });
+        const webAssets = staticRootReporter?.() ?? null;
+        res.json({ config: CLOUD_MODE ? redactConfig(config) : config, envTokenHint, installDir: CLOUD_MODE ? null : WALNUT_INSTALL_DIR, notesDir: CLOUD_MODE ? null : NOTES_DIR, processNice, memory, canRevealLocalFiles, remoteIdUniquenessGaps, cloud: CLOUD_MODE, webAssets });
       } catch (err2) {
         next(err2);
       }
@@ -159226,6 +159492,9 @@ var init_session_chat = __esm({
 
 // src/web/routes/browser-logs.ts
 import { Router as Router31 } from "express";
+function entrySubsystem(entry) {
+  return entry.subsystem && ENTRY_SUBSYSTEMS.has(entry.subsystem) ? entry.subsystem : "browser";
+}
 function checkRate(client, entryCount) {
   const now = Date.now();
   let state9 = clientRates.get(client);
@@ -159267,10 +159536,11 @@ function writeEntries(entries) {
     if (entry.args) meta.args = truncate(entry.args, 1e3);
     if (entry.url) meta.url = entry.url;
     if (entry.count && entry.count > 1) meta.count = entry.count;
+    if (entry.client === "mac-app") meta.client = entry.client;
     writeLogEntry({
       time: entry.time,
       level: mapLevel(entry.level),
-      subsystem: "browser",
+      subsystem: entrySubsystem(entry),
       message: truncate(entry.message, 2e3),
       browserLevel: entry.level,
       // preserve original level (e.g. 'log' vs 'info')
@@ -159293,13 +159563,14 @@ function registerBrowserLogsRpc() {
     writeEntries(entries);
   });
 }
-var RATE_WINDOW_MS, RATE_LIMIT, clientRates, REST_MAX_ENTRIES, browserLogsRouter;
+var ENTRY_SUBSYSTEMS, RATE_WINDOW_MS, RATE_LIMIT, clientRates, REST_MAX_ENTRIES, browserLogsRouter;
 var init_browser_logs = __esm({
   "src/web/routes/browser-logs.ts"() {
     "use strict";
     init_handler();
     init_logging();
     init_logger();
+    ENTRY_SUBSYSTEMS = /* @__PURE__ */ new Set(["browser", "desktop"]);
     RATE_WINDOW_MS = 1e4;
     RATE_LIMIT = 500;
     clientRates = /* @__PURE__ */ new WeakMap();
@@ -163643,6 +163914,7 @@ var init_session_health_monitor = __esm({
           log.session.info("health monitor: drained orphan dead-pool", { orphanCount: orphanIds.length, written: written.length });
         }
         if (sessions3.length === 0) {
+          if (!ctx.overBudget()) await this.checkSnapshotPull(sessions3, ctx, allSessions);
           const total = Date.now() - checkT0;
           if (total > 500) log.session.warn("health monitor: check() slow (no active sessions)", { totalMs: total, orphanMs: tOrphan - checkT0, recoverMs: tRecover - tOrphan });
           return;
@@ -163672,7 +163944,7 @@ var init_session_health_monitor = __esm({
         await this.reconcilePendingBackgroundTasks(sessions3);
         endPhase("pendingBgTasks");
         if (ctx.overBudget()) return;
-        await this.checkSnapshotPull(sessions3, ctx);
+        await this.checkSnapshotPull(sessions3, ctx, allSessions);
         endPhase("snapshotPull");
         if (ctx.overBudget()) return;
         const reconciledIds = await this.reconcileStuckRunningSessions(sessions3, taskMap);
@@ -164166,15 +164438,39 @@ var init_session_health_monitor = __esm({
         bus.emit(EventNames.SESSION_WILL_REAP, payload, ["*"], { source: "health-monitor" });
       }
       /**
-       * C2 snapshot pull channel (contract §5): every 30s tick, for records in
-       * {running, idle} on a native (non-codex, non-embedded/sdk) engine whose
-       * host has a POOLED CONNECTED DaemonConnection advertising 'snapshot-v1',
-       * PULL getState and feed the snapshot to applySnapshot. NEVER dials a new
-       * connection. Sequential, capped at 10 sids/tick, per-sid 25s spacing.
+       * C2 snapshot pull channel (contract §5): every 30s tick, PULL getState from
+       * the host's POOLED CONNECTED DaemonConnection advertising 'snapshot-v1' and
+       * feed the answer to applySnapshot. NEVER dials a new connection, always
+       * sequential. TWO candidate classes with SEPARATE budgets and cadences:
+       *
+       *  - LIVE — {running, idle}: 10 sids/tick, 25s per-sid spacing. The steady
+       *    state channel.
+       *  - RE-EXAMINATION — {error, stopped} whose cause is NOT positively terminal
+       *    (classifySessionError) and whose last_status_change is inside
+       *    RESCUABLE_STOPPED_WINDOW_MS: 5 sids/tick, 5 min per-sid spacing. Same
+       *    engine/provider/awaiting_spawn/archived exclusions as the live class.
        *
-       * TWO fairness/budget properties this loop must keep (C8/C9/C12/C29):
+       * WHY RE-EXAMINATION EXISTS — do not "optimize" the error class back out. A
+       * wrongly-'error' record was a two-sided deadlock: this lane is the ONE writer
+       * the enforce-mode gate sanctions for a snapshot-covered session, and while it
+       * looked at live records only it never re-derived status for an 'error' one.
+       * recoverInfraFailedSessions DOES look, but the fix it writes
+       * (('health-monitor','auto_recovered_dead')) is itself category-①, so the gate
+       * drops the whole patch — the lane allowed to write refused to look, and the
+       * lane that looked was not allowed to write. Records froze in 'error' with
+       * "Connection lost — unable to reach remote host" for hours after their host
+       * came back (2026-09-03, a remote dev host whose tunnel flapped: prose still on
+       * the record 2h after the reconnect), burning a 30s log-churn loop the whole
+       * time. Terminality is decided STRUCTURALLY, never by matching errorMessage
+       * prose — see the header of session-error-kind.ts for why that ban exists.
        *
-       *  - It honors the TickContext budget INSIDE the loop (same discipline as
+       * Re-examination candidates come from a WIDER pool than the live ones: the
+       * tick's own working set drops every 'error' row (isTerminalSession), so the
+       * caller passes the unfiltered health-scan set for this class only.
+       *
+       * THREE fairness/budget properties both classes must keep (C8/C9/C12/C29):
+       *
+       *  - The TickContext budget is honored INSIDE the loop (same discipline as
        *    checkHungSessions). Each iteration is a real daemon RPC with a
        *    probe-timeout ceiling, so 10 slow hosts could burn 10 × the probe
        *    timeout sequentially BEFORE the authoritative reconcile phases that run
@@ -164183,70 +164479,101 @@ var init_session_health_monitor = __esm({
        *    next tick (see the rotation below).
        *
        *  - Candidates are ordered by lastPullAt ASCENDING (never-pulled first),
-       *    which turns the 10/tick cap into a round-robin. In list order the SAME
-       *    first ten sids were pulled every tick and — because the 25s spacing is
-       *    shorter than the 30s cadence — sids 11+ were never pulled at all: the
-       *    pull channel silently did not exist for them.
+       *    which turns each cap into a round-robin. In list order the SAME first ten
+       *    sids were pulled every tick and — because the 25s spacing is shorter than
+       *    the 30s cadence — sids 11+ were never pulled at all: the pull channel
+       *    silently did not exist for them. Each class rotates on its OWN timestamps.
+       *
+       *  - The classes cannot spend each other's budget. Re-examination is
+       *    speculative ("is this record still true?") and a settled-death cohort
+       *    dwarfs the live set (the live DB measured 100 stopped candidates against
+       *    4 error rows), so it must cost a handful of cheap RPCs per tick and
+       *    nothing more — the same reasoning as MAX_STOPPED_PROBES_PER_TICK below.
        */
       snapshotPullAt = /* @__PURE__ */ new Map();
-      async checkSnapshotPull(sessions3, ctx) {
+      /** Separate from snapshotPullAt on purpose: the two classes rotate
+       *  independently, so a live pull can never reset the slow re-examination
+       *  cadence (or vice versa) when a record moves between them. */
+      snapshotReexamPullAt = /* @__PURE__ */ new Map();
+      async checkSnapshotPull(sessions3, ctx, reexamPool = sessions3) {
         const PULL_MIN_GAP_MS = 25e3;
         const MAX_PULLS_PER_TICK = 10;
+        const REEXAM_MIN_GAP_MS = 5 * 6e4;
+        const MAX_REEXAM_PULLS_PER_TICK = 5;
         try {
           const { getSnapshotStatusMode: getSnapshotStatusMode2 } = await Promise.resolve().then(() => (init_session_snapshot_gate(), session_snapshot_gate_exports));
           if (getSnapshotStatusMode2() === "off") return;
           const { getPooledSnapshotConnection: getPooledSnapshotConnection2 } = await Promise.resolve().then(() => (init_daemon_connection(), daemon_connection_exports));
           const { applySnapshot: applySnapshot2 } = await Promise.resolve().then(() => (init_session_snapshot_apply(), session_snapshot_apply_exports));
           const now = Date.now();
-          const candidates = sessions3.filter((s4) => {
-            if (s4.process_status !== "running" && s4.process_status !== "idle") return false;
+          const pullable = (s4) => {
+            if (s4.archived) return false;
             if (!engineCaps(s4.engine).snapshotPull) return false;
             if (s4.provider === "embedded" || s4.provider === "sdk") return false;
-            if (s4.status_reason === "awaiting_spawn") return false;
-            const lastPull = this.snapshotPullAt.get(s4.claudeSessionId) ?? 0;
-            return now - lastPull >= PULL_MIN_GAP_MS;
-          }).sort((a8, b8) => (this.snapshotPullAt.get(a8.claudeSessionId) ?? 0) - (this.snapshotPullAt.get(b8.claudeSessionId) ?? 0));
-          let pulled = 0;
-          let capped = false;
-          for (const s4 of candidates) {
-            if (ctx?.overBudget()) {
-              log.session.warn("health monitor: checkSnapshotPull abandoned mid-loop (over budget)", {
-                pulled,
-                candidateCount: candidates.length
-              });
-              break;
-            }
-            const conn = getPooledSnapshotConnection2(s4.host);
-            if (!conn) continue;
-            if (pulled >= MAX_PULLS_PER_TICK) {
-              capped = true;
-              break;
-            }
-            pulled++;
-            this.snapshotPullAt.set(s4.claudeSessionId, now);
-            try {
-              const resp = await probeWithTimeout(
-                conn.send("getState", { sid: s4.claudeSessionId }),
-                null,
-                "snapshot-pull-getState",
-                s4.claudeSessionId
-              );
-              const snapshot2 = resp?.ok ? resp.snapshot : void 0;
-              if (snapshot2) await applySnapshot2(s4.claudeSessionId, snapshot2, "pull-30s");
-            } catch (err2) {
-              log.session.debug("health monitor: snapshot pull failed", {
-                sessionId: s4.claudeSessionId,
-                host: s4.host ?? "__local__",
-                error: err2 instanceof Error ? err2.message : String(err2)
-              });
+            return s4.status_reason !== "awaiting_spawn";
+          };
+          const byPullAge = (at) => (a8, b8) => (at.get(a8.claudeSessionId) ?? 0) - (at.get(b8.claudeSessionId) ?? 0);
+          const live = sessions3.filter((s4) => {
+            if (s4.process_status !== "running" && s4.process_status !== "idle") return false;
+            if (!pullable(s4)) return false;
+            return now - (this.snapshotPullAt.get(s4.claudeSessionId) ?? 0) >= PULL_MIN_GAP_MS;
+          }).sort(byPullAge(this.snapshotPullAt));
+          const reexam = reexamPool.filter((s4) => {
+            if (s4.process_status !== "error" && s4.process_status !== "stopped") return false;
+            if (!pullable(s4)) return false;
+            if (classifySessionError(s4) === "terminal") return false;
+            const changedAt = s4.last_status_change ? Date.parse(s4.last_status_change) : NaN;
+            if (!Number.isFinite(changedAt)) return false;
+            if (now - changedAt > RESCUABLE_STOPPED_WINDOW_MS) return false;
+            return now - (this.snapshotReexamPullAt.get(s4.claudeSessionId) ?? 0) >= REEXAM_MIN_GAP_MS;
+          }).sort(byPullAge(this.snapshotReexamPullAt));
+          let abandoned = false;
+          const runClass = async (candidates, cap2, at, candidateClass) => {
+            let pulled = 0;
+            for (const s4 of candidates) {
+              if (ctx?.overBudget()) {
+                abandoned = true;
+                log.session.warn("health monitor: checkSnapshotPull abandoned mid-loop (over budget)", {
+                  pulled,
+                  candidateCount: candidates.length,
+                  candidateClass
+                });
+                break;
+              }
+              const conn = getPooledSnapshotConnection2(s4.host);
+              if (!conn) continue;
+              if (pulled >= cap2) {
+                log.session.info("health monitor: snapshot pull capped this tick", {
+                  cap: cap2,
+                  sessionCount: sessions3.length,
+                  candidateCount: candidates.length,
+                  candidateClass
+                });
+                break;
+              }
+              pulled++;
+              at.set(s4.claudeSessionId, now);
+              try {
+                const resp = await probeWithTimeout(
+                  conn.send("getState", { sid: s4.claudeSessionId }),
+                  null,
+                  "snapshot-pull-getState",
+                  s4.claudeSessionId
+                );
+                const snapshot2 = resp?.ok ? resp.snapshot : void 0;
+                if (snapshot2) await applySnapshot2(s4.claudeSessionId, snapshot2, "pull-30s");
+              } catch (err2) {
+                log.session.debug("health monitor: snapshot pull failed", {
+                  sessionId: s4.claudeSessionId,
+                  host: s4.host ?? "__local__",
+                  error: err2 instanceof Error ? err2.message : String(err2)
+                });
+              }
             }
-          }
-          if (capped) {
-            log.session.info("health monitor: snapshot pull capped this tick", {
-              cap: MAX_PULLS_PER_TICK,
-              sessionCount: sessions3.length,
-              candidateCount: candidates.length
-            });
+          };
+          await runClass(live, MAX_PULLS_PER_TICK, this.snapshotPullAt, "live");
+          if (!abandoned) {
+            await runClass(reexam, MAX_REEXAM_PULLS_PER_TICK, this.snapshotReexamPullAt, "reexam");
           }
           if (this.snapshotPullAt.size > 200) {
             const liveIds = new Set(sessions3.map((s4) => s4.claudeSessionId));
@@ -164254,6 +164581,12 @@ var init_session_health_monitor = __esm({
               if (!liveIds.has(sid)) this.snapshotPullAt.delete(sid);
             }
           }
+          if (this.snapshotReexamPullAt.size > 200) {
+            const poolIds = new Set(reexamPool.map((s4) => s4.claudeSessionId));
+            for (const sid of this.snapshotReexamPullAt.keys()) {
+              if (!poolIds.has(sid)) this.snapshotReexamPullAt.delete(sid);
+            }
+          }
         } catch (err2) {
           log.session.warn("health monitor: checkSnapshotPull failed", {
             error: err2 instanceof Error ? err2.message : String(err2)
@@ -164416,6 +164749,31 @@ var init_session_health_monitor = __esm({
           });
         }
       }
+      /**
+       * Can a scheduled auto-recovery actually FIRE for this record?
+       *
+       * fire() (session-auto-recover) hard-requires the linked task to still be
+       * IN_PROGRESS — AGENT_COMPLETE means the work was already handed back and
+       * resuming would talk over the human. Arming a recovery that cannot pass that
+       * check is not free: the 30s tick re-armed it forever and each arming logged
+       * an abort 20s later (measured running for 2+ hours on one session), while
+       * `if (armed) continue` also skipped the phase sync that IS appropriate there.
+       *
+       * A lookup that cannot answer (no task id, deleted task, DB error) returns
+       * true: only a KNOWN non-IN_PROGRESS phase blocks arming, so a transient read
+       * failure can never disable recovery. schedule()'s own guards still apply.
+       */
+      async autoRecoverCanFire(s4) {
+        if (!s4.taskId) return true;
+        try {
+          const { getTask: getTask2 } = await Promise.resolve().then(() => (init_task_manager(), task_manager_exports));
+          const task = await getTask2(s4.taskId);
+          if (!task) return true;
+          return task.phase === "IN_PROGRESS";
+        } catch {
+          return true;
+        }
+      }
       /**
        * Auto-recover remote sessions stuck in 'error' with "Connection lost" message.
        *
@@ -164502,28 +164860,31 @@ var init_session_health_monitor = __esm({
                 } else if (wasStopped) {
                   continue;
                 } else {
-                  const updated = await updateSessionRecord2(s4.claudeSessionId, {
-                    process_status: "stopped",
-                    errorMessage: void 0,
-                    errorKind: "infra",
-                    activity: void 0,
-                    last_status_change: now,
-                    status_reason: "auto_recovered_dead",
-                    status_changed_by: "health-monitor"
-                  });
-                  emitSessionStatusChanged(
-                    updated,
-                    {},
-                    ["*"],
-                    { source: "health-monitor", urgency: "urgent" }
-                  );
-                  log.session.info("health monitor: auto-recovered connection-lost session (process dead)", {
-                    sessionId: s4.claudeSessionId,
-                    host: s4.host,
-                    alive: false
-                  });
+                  const { isSnapshotCovered: isSnapshotCovered2 } = await Promise.resolve().then(() => (init_session_snapshot_gate(), session_snapshot_gate_exports));
+                  if (!isSnapshotCovered2(s4.claudeSessionId)) {
+                    const updated = await updateSessionRecord2(s4.claudeSessionId, {
+                      process_status: "stopped",
+                      errorMessage: void 0,
+                      errorKind: "infra",
+                      activity: void 0,
+                      last_status_change: now,
+                      status_reason: "auto_recovered_dead",
+                      status_changed_by: "health-monitor"
+                    });
+                    emitSessionStatusChanged(
+                      updated,
+                      {},
+                      ["*"],
+                      { source: "health-monitor", urgency: "urgent" }
+                    );
+                    log.session.info("health monitor: auto-recovered connection-lost session (process dead)", {
+                      sessionId: s4.claudeSessionId,
+                      host: s4.host,
+                      alive: false
+                    });
+                  }
                   const { scheduleSessionAutoRecover: scheduleSessionAutoRecover2 } = await Promise.resolve().then(() => (init_session_auto_recover(), session_auto_recover_exports));
-                  const armed = scheduleSessionAutoRecover2(s4, s4.status_reason ?? "daemon_reported_exit");
+                  const armed = await this.autoRecoverCanFire(s4) && scheduleSessionAutoRecover2(s4, s4.status_reason ?? "daemon_reported_exit");
                   if (armed) continue;
                   if (s4.taskId) {
                     try {
@@ -172673,6 +173034,20 @@ var init_session_lifecycle_v1 = __esm({
         next(err2);
       }
     });
+    sessionLifecycleV1Router.post("/sessions/:id/recheck", async (req, res, next) => {
+      try {
+        const sessionId = validSid2(req, res);
+        if (!sessionId) return;
+        if (CLOUD_MODE) {
+          await relayControlAction(res, "recheck", sessionId, void 0, 200);
+          return;
+        }
+        const { recheckSession: recheckSession2 } = await Promise.resolve().then(() => (init_session_lifecycle(), session_lifecycle_exports));
+        await runLocal(res, next, 200, () => recheckSession2(sessionId));
+      } catch (err2) {
+        next(err2);
+      }
+    });
     sessionLifecycleV1Router.post("/sessions/:id/permission", async (req, res, next) => {
       try {
         const sessionId = validSid2(req, res);
@@ -184587,6 +184962,16 @@ async function resolveCredentialHealth() {
     return { hasReadyProvider: false, source: "none" };
   }
 }
+async function isWalnutAnsweringOn(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/system/health`, { signal: AbortSignal.timeout(1500) });
+    if (!res.ok) return false;
+    const body3 = await res.json();
+    return !!body3 && typeof body3 === "object" && "hasReadyProvider" in body3;
+  } catch {
+    return false;
+  }
+}
 async function startServer(options = {}) {
   if (httpServer) throw new Error("Server already running. Call stopServer() first.");
   bootCompleted = false;
@@ -185113,6 +185498,7 @@ async function startServer(options = {}) {
   });
   if (!dev) {
     const staticDir = (() => {
+      if (process.env.WALNUT_WEB_STATIC_DIR) return process.env.WALNUT_WEB_STATIC_DIR;
       let dir2 = path184.dirname(fileURLToPath13(import.meta.url));
       for (let i8 = 0; i8 < 5; i8++) {
         const candidate = path184.join(dir2, "web", "static", "index.html");
@@ -185129,11 +185515,65 @@ async function startServer(options = {}) {
       }
       return path184.join(process.cwd(), "dist", "web", "static");
     })();
+    const mirrorDir = process.env.WALNUT_WEB_STATIC_MIRROR || path184.join(WALNUT_HOME, "cache", "web-static");
+    let mirrorReady = false;
+    try {
+      const want = fs113.readFileSync(path184.join(staticDir, "index.html"), "utf-8");
+      let have = null;
+      try {
+        have = fs113.readFileSync(path184.join(mirrorDir, "index.html"), "utf-8");
+      } catch {
+      }
+      if (have !== want) {
+        fs113.rmSync(mirrorDir, { recursive: true, force: true });
+        fs113.mkdirSync(path184.dirname(mirrorDir), { recursive: true });
+        fs113.cpSync(staticDir, mirrorDir, { recursive: true });
+      }
+    } catch (err2) {
+      log.web.warn("could not refresh the web-asset mirror", {
+        mirrorDir,
+        error: err2 instanceof Error ? err2.message : String(err2)
+      });
+    }
+    try {
+      mirrorReady = fs113.statSync(path184.join(mirrorDir, "index.html")).isFile();
+    } catch {
+      mirrorReady = false;
+    }
     app.use(express3.static(staticDir));
+    if (mirrorReady) app.use(express3.static(mirrorDir));
+    const checkStaticRoot = () => {
+      try {
+        return fs113.statSync(path184.join(staticDir, "index.html")).isFile();
+      } catch {
+        return false;
+      }
+    };
+    let staticRootOk = checkStaticRoot();
+    if (!staticRootOk) {
+      log.web.error("web assets are NOT servable at startup", { staticDir, mirrorReady });
+    }
+    const staticRootTimer = setInterval(() => {
+      const ok = checkStaticRoot();
+      if (ok === staticRootOk) return;
+      staticRootOk = ok;
+      if (ok) log.web.info("web assets are servable again", { staticDir });
+      else log.web.error("web assets VANISHED from under the running server", { staticDir, mirrorReady });
+    }, 6e4);
+    staticRootTimer.unref();
+    setStaticRootReporter(() => ({ staticDir, ok: staticRootOk, mirrorDir, mirrorReady }));
     app.use((req, res, next) => {
       if (req.method !== "GET" || req.path.startsWith("/api/")) return next();
       if (isStaticAssetPath(req.path)) return next();
-      res.sendFile("index.html", { root: staticDir });
+      res.sendFile("index.html", { root: staticDir }, (err2) => {
+        if (!err2) return;
+        if (mirrorReady) {
+          res.sendFile("index.html", { root: mirrorDir }, () => {
+          });
+          return;
+        }
+        next(err2);
+      });
     });
   }
   app.use("/api", notFoundHandler);
@@ -185153,9 +185593,21 @@ async function startServer(options = {}) {
   }
   httpServer = createServer(app);
   attachWss(httpServer);
-  await new Promise((resolve, reject) => {
-    httpServer.listen(port, () => resolve());
-    httpServer.once("error", reject);
+  try {
+    await new Promise((resolve, reject) => {
+      httpServer.once("error", reject);
+      httpServer.listen(port, () => resolve());
+    });
+  } catch (err2) {
+    if (err2?.code !== "EADDRINUSE") throw err2;
+    const already = await isWalnutAnsweringOn(port);
+    throw new Error(
+      already ? `Walnut is already running at http://localhost:${port} (EADDRINUSE). Open that address; there is nothing to start.` : `Port ${port} is in use by another program (EADDRINUSE). Start Walnut on a free one instead, for example:
+    open-walnut web --port ${port + 1}`
+    );
+  }
+  httpServer.on("error", (err2) => {
+    log.web.error("http server error after listen", { error: err2 instanceof Error ? err2.message : String(err2) });
   });
   const label = dev ? "dev" : "production";
   log.web.info(`server listening on http://localhost:${port}`, { mode: label, port });
@@ -185165,6 +185617,7 @@ async function startServer(options = {}) {
       const { updateInstanceLockPort: updateInstanceLockPort2 } = await Promise.resolve().then(() => (init_instance_lock(), instance_lock_exports));
       updateInstanceLockPort2(bound.port);
       setPluginApiBase(`http://127.0.0.1:${bound.port}`);
+      process.env.WALNUT_SERVER_URL = `http://localhost:${bound.port}`;
     }
   }
   if (CLOUD_MODE) {