@dotobokuri/fleet-console 1.67.0 → 1.68.0

package/dist/cli.mjs

@@ -917,16 +917,14 @@ function sanitizeGlobalOptionsData(value) {
     return { data: createEmptyGlobalOptionsData(), changed: true };
   }
   const agentIdleDormantMinutes = sanitizeAgentIdleDormantMinutes(value.agentIdleDormantMinutes);
-  const hasCanonicalMode = "claudeGatewaySystemPromptMode" in value;
-  const validMode = sanitizeClaudeGatewaySystemPromptMode(value.claudeGatewaySystemPromptMode);
-  const claudeGatewaySystemPromptMode = validMode ?? (!hasCanonicalMode && value.replaceClaudeGatewaySystemPrompt === true ? "replace" : "append");
+  const claudeCodeSystemPrompt = sanitizeClaudeCodeSystemPrompt(value.claudeCodeSystemPrompt);
   const data = {
     version: GLOBAL_OPTIONS_VERSION,
     ...agentIdleDormantMinutes !== void 0 ? { agentIdleDormantMinutes } : {},
-    claudeGatewaySystemPromptMode
+    ...claudeCodeSystemPrompt !== void 0 ? { claudeCodeSystemPrompt } : {}
   };
-  const allowedKeys = /* @__PURE__ */ new Set(["version", "agentIdleDormantMinutes", "claudeGatewaySystemPromptMode"]);
-  const changed = Object.keys(value).some((key) => !allowedKeys.has(key)) || "agentIdleDormantMinutes" in value && agentIdleDormantMinutes === void 0 || validMode === void 0;
+  const allowedKeys = /* @__PURE__ */ new Set(["version", "agentIdleDormantMinutes", "claudeCodeSystemPrompt"]);
+  const changed = Object.keys(value).some((key) => !allowedKeys.has(key)) || "agentIdleDormantMinutes" in value && agentIdleDormantMinutes === void 0 || "claudeCodeSystemPrompt" in value && claudeCodeSystemPrompt === void 0;
   return { data, changed };
 }
 function sanitizeAgentIdleDormantMinutes(value) {
@@ -934,8 +932,8 @@ function sanitizeAgentIdleDormantMinutes(value) {
   if (typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value > 0) return value;
   return void 0;
 }
-function sanitizeClaudeGatewaySystemPromptMode(value) {
-  return value === "append" || value === "replace" || value === "off" ? value : void 0;
+function sanitizeClaudeCodeSystemPrompt(value) {
+  return value === "on" || value === "off" ? value : void 0;
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -12259,6 +12257,48 @@ function createDesktopThemeRouter(deps) {
     return true;
   };
 }
+var DESKTOP_UPDATE_PATH = "/api/v1/desktop/update";
+var DESKTOP_UPDATE_EVENTS_PATH = "/api/v1/desktop/update/events";
+var DESKTOP_UPDATE_EVENT = "desktop:update";
+var emptyDesktopUpdateRequest = () => ({ requestedVersion: null, requestId: null });
+var DESKTOP_UPDATE_API_CATALOG = [
+  {
+    method: "GET",
+    path: DESKTOP_UPDATE_PATH,
+    summary: "Read whether an update was requested for the shell that owns this window to perform.",
+    category: "Desktop",
+    gate: "origin-strict",
+    transport: "http"
+  },
+  {
+    method: "GET",
+    path: DESKTOP_UPDATE_EVENTS_PATH,
+    summary: "Stream update requests the owning shell must perform.",
+    category: "Desktop",
+    gate: "origin-strict",
+    transport: "sse"
+  }
+];
+function createDesktopUpdateRouter(deps) {
+  return ({ req, res, pathname }) => {
+    if (pathname !== DESKTOP_UPDATE_PATH && pathname !== DESKTOP_UPDATE_EVENTS_PATH) return false;
+    if (req.method !== "GET") {
+      deps.writeJson(res, 405, { error: "Method not allowed" });
+      return true;
+    }
+    if (!deps.isAuthorized(req)) {
+      deps.writeJson(res, 401, { error: "unauthorized" });
+      return true;
+    }
+    const snapshot = deps.getUpdateRequest();
+    if (pathname === DESKTOP_UPDATE_PATH) {
+      deps.writeJson(res, 200, snapshot);
+      return true;
+    }
+    deps.subscribe(res, snapshot);
+    return true;
+  };
+}
 var REMOTE_AUTO_PORT_MIN = 49152;
 var REMOTE_AUTO_PORT_MAX = 65535;
 var REMOTE_AUTO_PORT_ATTEMPTS = 12;
@@ -13307,6 +13347,7 @@ function buildApiCatalog(extraEntries = []) {
     ...DESKTOP_FULLSCREEN_API_CATALOG,
     ...DESKTOP_SHELL_API_CATALOG,
     ...DESKTOP_THEME_API_CATALOG,
+    ...DESKTOP_UPDATE_API_CATALOG,
     ...GLOBAL_SETTINGS_API_CATALOG,
     ...PLUGIN_SETTINGS_API_CATALOG,
     ...SYSTEM_FONTS_API_CATALOG,
@@ -16882,10 +16923,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path42) {
-  if (!path42)
+function getElementAtPath(obj, path43) {
+  if (!path43)
     return obj;
-  return path42.reduce((acc, key) => acc?.[key], obj);
+  return path43.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -17294,11 +17335,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path42, issues) {
+function prefixIssues(path43, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path42);
+    iss.path.unshift(path43);
     return iss;
   });
 }
@@ -17445,16 +17486,16 @@ function flattenError(error51, mapper = (issue3) => issue3.message) {
 }
 function formatError2(error51, mapper = (issue3) => issue3.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path42 = []) => {
+  const processError = (error52, path43 = []) => {
     for (const issue3 of error52.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
-        issue3.errors.map((issues) => processError({ issues }, [...path42, ...issue3.path]));
+        issue3.errors.map((issues) => processError({ issues }, [...path43, ...issue3.path]));
       } else if (issue3.code === "invalid_key") {
-        processError({ issues: issue3.issues }, [...path42, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path43, ...issue3.path]);
       } else if (issue3.code === "invalid_element") {
-        processError({ issues: issue3.issues }, [...path42, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path43, ...issue3.path]);
       } else {
-        const fullpath = [...path42, ...issue3.path];
+        const fullpath = [...path43, ...issue3.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue3));
         } else {
@@ -17481,17 +17522,17 @@ function formatError2(error51, mapper = (issue3) => issue3.message) {
 }
 function treeifyError(error51, mapper = (issue3) => issue3.message) {
   const result = { errors: [] };
-  const processError = (error52, path42 = []) => {
+  const processError = (error52, path43 = []) => {
     var _a3, _b;
     for (const issue3 of error52.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
-        issue3.errors.map((issues) => processError({ issues }, [...path42, ...issue3.path]));
+        issue3.errors.map((issues) => processError({ issues }, [...path43, ...issue3.path]));
       } else if (issue3.code === "invalid_key") {
-        processError({ issues: issue3.issues }, [...path42, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path43, ...issue3.path]);
       } else if (issue3.code === "invalid_element") {
-        processError({ issues: issue3.issues }, [...path42, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path43, ...issue3.path]);
       } else {
-        const fullpath = [...path42, ...issue3.path];
+        const fullpath = [...path43, ...issue3.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue3));
           continue;
@@ -17523,8 +17564,8 @@ function treeifyError(error51, mapper = (issue3) => issue3.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path42 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path42) {
+  const path43 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path43) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -30188,13 +30229,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path42 = ref.slice(1).split("/").filter(Boolean);
-  if (path42.length === 0) {
+  const path43 = ref.slice(1).split("/").filter(Boolean);
+  if (path43.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path42[0] === defsKey) {
-    const key = path42[1];
+  if (path43[0] === defsKey) {
+    const key = path43[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -33182,8 +33223,8 @@ function bootEnumDescriptorProto(init) {
 }
 
 // ../../node_modules/.pnpm/@bufbuild+protobuf@2.13.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/message.js
-function messageDesc(file2, path42, ...paths) {
-  return paths.reduce((acc, cur) => acc.nestedMessages[cur], file2.messages[path42]);
+function messageDesc(file2, path43, ...paths) {
+  return paths.reduce((acc, cur) => acc.nestedMessages[cur], file2.messages[path43]);
 }
 
 // ../../node_modules/.pnpm/@bufbuild+protobuf@2.13.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/descriptor_pb.js
@@ -33778,7 +33819,7 @@ var benchmarks_default = {
 };
 var models_default = {
   version: 1,
-  updatedAt: "2026-08-17T00:00:00Z",
+  updatedAt: "2026-08-19T00:00:00Z",
   providers: {
     codex: {
       name: "Codex",
@@ -34509,7 +34550,7 @@ var models_default = {
     xai: {
       name: "xAI",
       defaultModel: "grok-4.6",
-      source: "official Grok CLI 1.0.3 ~/.grok/models_cache.json from GET https://cli-chat-proxy.grok.com/v1/models (observed 2026-08-13)",
+      source: "official Grok CLI 1.0.4 ~/.grok/models_cache.json from GET https://cli-chat-proxy.grok.com/v1/models (grok-4.6 observed 2026-08-13); grok-composer-2.5-fast is the account-verified OpenCodex xAI identity, live POST /v1/responses accepted on the Grok CLI proxy 2026-08-19 (absent from the public docs.x.ai catalog)",
       models: [
         {
           modelId: "grok-4.6",
@@ -34527,6 +34568,13 @@ var models_default = {
             ]
           },
           benchmarkKey: "grok-4.6"
+        },
+        {
+          modelId: "grok-composer-2.5-fast",
+          name: "Grok-Composer-2.5-Fast",
+          capabilityClass: "light",
+          wire: "responses",
+          contextWindow: 2e5
         }
       ]
     }
@@ -36440,13 +36488,14 @@ function vendorFlagSettings(options) {
   return Object.keys(settings2).length > 0 ? { settings: settings2 } : {};
 }
 function vendorSystemPrompt(systemPrompt) {
+  if (systemPrompt?.mode === "preset") return { type: "preset", preset: "claude_code" };
   const text = systemPrompt?.text;
   if (typeof text !== "string" || text.length === 0) {
     throw new TypeError("turn.systemPrompt.text must be a non-empty string.");
   }
   if (systemPrompt.mode === "replace") return text;
   if (systemPrompt.mode === "append") return { type: "preset", preset: "claude_code", append: text };
-  throw new TypeError(`turn.systemPrompt.mode must be "replace" or "append", got: ${String(systemPrompt.mode)}`);
+  throw new TypeError(`turn.systemPrompt.mode must be "replace", "append", or "preset", got: ${String(systemPrompt.mode)}`);
 }
 function assertKnownTurnKeys(turn) {
   const unknown2 = Object.keys(turn).filter((key) => !CLAUDE_GATEWAY_TURN_KEYS.includes(key));
@@ -39958,6 +40007,86 @@ function resolveConsolePath(pathname) {
   if (!path18__default.extname(withoutPrefix)) return "index.html";
   return withoutPrefix;
 }
+var CONSOLE_UPDATE_PROGRESS_FILE = "update-progress.json";
+var IDLE_CONSOLE_UPDATE_PROGRESS = { state: "idle" };
+var CONSOLE_UPDATE_PROGRESS_STALE_MS = 10 * 60 * 1e3;
+var CONSOLE_UPDATE_OUTCOME_TTL_MS = 6 * 60 * 60 * 1e3;
+var RUNNING_PHASES = /* @__PURE__ */ new Set(["starting", "preflight-ok", "stopping-console", "installing", "starting-daemon"]);
+var PROGRESS_FILE_MODE = 384;
+function consoleUpdateProgressPath(dataDir) {
+  return path18__default.join(dataDir, CONSOLE_UPDATE_PROGRESS_FILE);
+}
+function readConsoleUpdateProgress(dataDir, deps = {}) {
+  const readFile7 = deps.readFile ?? ((filePath) => fs9__default.readFileSync(filePath, "utf8"));
+  const now = deps.now ?? Date.now;
+  let raw;
+  try {
+    raw = readFile7(consoleUpdateProgressPath(dataDir));
+  } catch {
+    return IDLE_CONSOLE_UPDATE_PROGRESS;
+  }
+  const record4 = parseConsoleUpdateProgressRecord(raw);
+  if (!record4) return IDLE_CONSOLE_UPDATE_PROGRESS;
+  return toConsoleUpdateProgressStatus(record4, now());
+}
+function toConsoleUpdateProgressStatus(record4, nowMs) {
+  const shared = {
+    phase: record4.phase,
+    startedAt: record4.startedAt,
+    targetVersion: record4.targetVersion,
+    fromVersion: record4.fromVersion,
+    ...record4.endpointChanged === true ? { endpointChanged: true } : {}
+  };
+  if (record4.phase === "completed" || record4.phase === "failed") {
+    const finishedAtMs = Date.parse(record4.updatedAt);
+    if (Number.isFinite(finishedAtMs) && nowMs - finishedAtMs > CONSOLE_UPDATE_OUTCOME_TTL_MS) return IDLE_CONSOLE_UPDATE_PROGRESS;
+    if (record4.phase === "completed") return { state: "completed", ...shared };
+    return { state: "failed", ...shared, ...record4.error ? { error: record4.error } : {} };
+  }
+  if (!RUNNING_PHASES.has(record4.phase)) return IDLE_CONSOLE_UPDATE_PROGRESS;
+  const updatedAtMs = Date.parse(record4.updatedAt);
+  if (Number.isFinite(updatedAtMs) && nowMs - updatedAtMs > CONSOLE_UPDATE_PROGRESS_STALE_MS) {
+    return { state: "failed", ...shared, error: "update_worker_lost" };
+  }
+  return { state: "running", ...shared };
+}
+function parseConsoleUpdateProgressRecord(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const entry = value;
+  if (!isConsoleUpdatePhase(entry.phase)) return null;
+  if (typeof entry.startedAt !== "string" || typeof entry.updatedAt !== "string") return null;
+  if (typeof entry.targetVersion !== "string" || typeof entry.fromVersion !== "string") return null;
+  return {
+    phase: entry.phase,
+    startedAt: entry.startedAt,
+    updatedAt: entry.updatedAt,
+    targetVersion: entry.targetVersion,
+    fromVersion: entry.fromVersion,
+    ...entry.endpointChanged === true ? { endpointChanged: true } : {},
+    ...typeof entry.error === "string" ? { error: entry.error } : {}
+  };
+}
+function isConsoleUpdatePhase(value) {
+  return typeof value === "string" && (RUNNING_PHASES.has(value) || value === "completed" || value === "failed");
+}
+function writeConsoleUpdateProgress(dataDir, record4, deps = {}) {
+  const makeDir = deps.makeDir ?? ((dirPath, options) => {
+    fs9__default.mkdirSync(dirPath, options);
+  });
+  const writeFile5 = deps.writeFile ?? ((filePath, content, options) => {
+    fs9__default.writeFileSync(filePath, content, { mode: options.mode });
+  });
+  makeDir(dataDir, { recursive: true, mode: 448 });
+  writeFile5(consoleUpdateProgressPath(dataDir), JSON.stringify(record4, null, 2), { mode: PROGRESS_FILE_MODE });
+}
+
+// core/host/update-apply.ts
 var PACKAGE_NAMES = ["@dotobokuri/fleet-console"];
 var WORKER_FILE_PREFIX = "fleet-console-update-";
 var WORKER_FILE_SUFFIX = ".mjs";
@@ -39988,21 +40117,34 @@ function createConsoleUpdateApplyService(deps = {}) {
     makeDir(request.dataDir, { recursive: true, mode: 448 });
     const statusFile = path18__default.join(request.dataDir, `${WORKER_FILE_PREFIX}${stamp}${STATUS_FILE_SUFFIX}`);
     const logFile = path18__default.join(request.dataDir, `${WORKER_FILE_PREFIX}${stamp}${LOG_FILE_SUFFIX}`);
+    const progressFile = path18__default.join(request.dataDir, CONSOLE_UPDATE_PROGRESS_FILE);
+    const startedAt = new Date(now()).toISOString();
     const script = emitConsoleUpdateWorkerScript({
       currentEndpoint: request.currentEndpoint,
       currentPackageRoot: request.currentPackageRoot,
       currentPid: request.currentPid,
+      fromVersion: request.fromVersion,
       lockFile: request.lockFile,
       logFile,
       packageManager,
       packageNames: PACKAGE_NAMES,
+      progressFile,
+      resumePort: readEndpointPort(request.currentEndpoint),
       serverModulePath,
       statusFile,
+      startedAt,
       targetVersion: request.targetVersion,
       workerPath
     });
     writeFile5(workerPath, script, { mode: TEMP_FILE_MODE });
     await spawnDetachedWorker(spawnWorker, execPath, [workerPath], childEnv);
+    writeConsoleUpdateProgress(request.dataDir, {
+      phase: "starting",
+      startedAt,
+      updatedAt: startedAt,
+      targetVersion: request.targetVersion,
+      fromVersion: request.fromVersion
+    }, { makeDir, writeFile: writeFile5 });
     return { accepted: true };
   }
   return { start };
@@ -40020,6 +40162,8 @@ const stopTimeoutMs = 60000;
 const startTimeoutMs = 60000;
 const sleepMs = 250;
 
+let consoleStopped = false;
+
 async function main() {
   writeStatus("starting");
   cleanupStaleWorkers();
@@ -40032,14 +40176,21 @@ async function main() {
   await installPackages(manager);
   writeStatus("starting-daemon");
   const lock = await startNewDaemon();
-  openBrowser(new URL("console/", lock.endpoint).toString());
-  writeStatus("completed");
+  // \uAC19\uC740 \uC8FC\uC18C\uB85C \uB3CC\uC544\uC654\uC73C\uBA74 \uC5F4\uB824 \uC788\uB358 \uD654\uBA74\uC774 \uC2A4\uC2A4\uB85C \uB2E4\uC2DC \uBD99\uB294\uB2E4 \u2014 \uC0C8 \uCC3D\uC740 \uADF8 \uBCF5\uADC0\uB97C
+  // \uB36E\uC5B4\uC4F8 \uBFD0\uC774\uB2E4. \uC8FC\uC18C\uB97C \uB418\uCC3E\uC9C0 \uBABB\uD588\uC744 \uB54C\uB9CC, \uAC08 \uACF3\uC744 \uC783\uC9C0 \uC54A\uB3C4\uB85D \uCC3D\uC744 \uC5F0\uB2E4.
+  const endpointChanged = !isSameEndpoint(lock.endpoint, config.currentEndpoint);
+  if (endpointChanged) openBrowser(new URL("console/", lock.endpoint).toString());
+  writeStatus("completed", endpointChanged ? { endpointChanged: true } : {});
 }
 
 main()
-  .catch((error) => {
-    writeStatus("failed", { error: sanitizeError(error) });
-    log("failed: " + sanitizeError(error));
+  .catch(async (error) => {
+    const reason = sanitizeError(error);
+    log("failed: " + reason);
+    // \uCF58\uC194\uC744 \uC774\uBBF8 \uB0B4\uB9B0 \uB4A4\uC5D0 \uC2E4\uD328\uD588\uB2E4\uBA74, \uC2E4\uD328\uB97C \uB9D0\uD560 \uD654\uBA74\uC870\uCC28 \uC5C6\uB2E4. \uC61B \uBC84\uC804\uC774\uB77C\uB3C4
+    // \uB2E4\uC2DC \uC138\uC6CC\uC57C \uC0AC\uC6A9\uC790\uAC00 \uBB34\uC5C7\uC774 \uC798\uBABB\uB410\uB294\uC9C0 \uC77D\uC744 \uC218 \uC788\uB2E4.
+    if (consoleStopped) await recoverConsoleBestEffort();
+    writeStatus("failed", { error: reason });
     process.exitCode = 1;
   })
   .finally(() => {
@@ -40051,12 +40202,24 @@ main()
   });
 
 function writeStatus(phase, extra = {}) {
-  const payload = {
+  const updatedAt = new Date().toISOString();
+  fs.writeFileSync(config.statusFile, JSON.stringify({ phase, updatedAt, ...extra }, null, 2), { mode: 0o600 });
+  // \uC7AC\uAE30\uB3D9\uD55C \uB370\uBAAC\uC774 \uC77D\uB294 \uAC83\uC740 \uC774 \uACE0\uC815 \uC774\uB984\uC758 \uAE30\uB85D\uC774\uB2E4. \uD0C0\uC784\uC2A4\uD0EC\uD504\uAC00 \uBD99\uC740 \uC704 \uD30C\uC77C\uC740
+  // \uC774 \uC2E4\uD589\uC758 \uC9C4\uB2E8 \uD754\uC801\uC774\uACE0, \uC544\uB798\uAC00 "\uBC29\uAE08 \uBB34\uC2A8 \uC77C\uC774 \uC788\uC5C8\uB294\uAC00"\uC5D0 \uB2F5\uD558\uB294 \uCABD\uC774\uB2E4.
+  const record = {
     phase,
-    updatedAt: new Date().toISOString(),
-    ...extra,
+    startedAt: config.startedAt,
+    updatedAt,
+    targetVersion: config.targetVersion,
+    fromVersion: config.fromVersion,
   };
-  fs.writeFileSync(config.statusFile, JSON.stringify(payload, null, 2), { mode: 0o600 });
+  if (extra.endpointChanged === true) record.endpointChanged = true;
+  if (typeof extra.error === "string") record.error = extra.error;
+  try {
+    fs.writeFileSync(config.progressFile, JSON.stringify(record, null, 2), { mode: 0o600 });
+  } catch {
+    // \uC9C4\uB2E8 \uAE30\uB85D\uC774 \uC5C6\uB2E4\uACE0 \uC5C5\uB370\uC774\uD2B8\uB97C \uBA48\uCD94\uC9C0\uB294 \uC54A\uB294\uB2E4.
+  }
   log("phase: " + phase);
 }
 
@@ -40081,6 +40244,7 @@ function cleanupStaleWorkers() {
 
 async function stopCurrentConsole() {
   writeStatus("stopping-console");
+  consoleStopped = true;
   try {
     process.kill(config.currentPid, "SIGTERM");
   } catch (error) {
@@ -40093,9 +40257,14 @@ async function waitForOldConsoleExit() {
   let escalated = false;
   while (Date.now() < deadline) {
     const pidGone = !isProcessAlive(config.currentPid);
-    const lockGone = !fs.existsSync(config.lockFile);
     const healthGone = await isHealthGone(config.currentEndpoint);
-    if (pidGone && lockGone && healthGone) return;
+    if (pidGone && healthGone) {
+      // \uC8FD\uC740 \uD504\uB85C\uC138\uC2A4\uAC00 \uB0A8\uAE34 \uB77D\uC740 \uC815\uC758\uC0C1 stale\uC774\uB2E4. \uADF8\uAC83\uC774 \uC2A4\uC2A4\uB85C \uC0AC\uB77C\uC9C0\uAE30\uB97C \uAE30\uB2E4\uB9AC\uBA74
+      // SIGKILL\uB85C \uB0B4\uB9B0 \uCF58\uC194 \uB4A4\uC5D0\uC11C\uB294 \uC601\uC6D0\uD788 \uAE30\uB2E4\uB9AC\uAC8C \uB418\uACE0, \uC5C5\uB370\uC774\uD2B8\uB294 \uB298 \uC2DC\uAC04 \uCD08\uACFC\uB85C
+      // \uB05D\uB09C\uB2E4. \uC6B0\uB9AC\uAC00 \uB0B4\uB9B0 \uADF8 pid\uC758 \uB77D\uC774\uBA74 \uC6B0\uB9AC\uAC00 \uCE58\uC6B4\uB2E4.
+      removeStaleLock();
+      return;
+    }
     if (!escalated && Date.now() > deadline - 10000 && isProcessAlive(config.currentPid)) {
       escalated = true;
       try {
@@ -40145,10 +40314,15 @@ async function installPackages(manager) {
   if (code !== 0) throw new Error("global package install failed with exit code " + code);
 }
 
+function daemonEnv() {
+  if (config.resumePort === null) return process.env;
+  return { ...process.env, FLEET_CONSOLE_RESUME_PORT: String(config.resumePort) };
+}
+
 async function startNewDaemon() {
   const child = spawn(process.execPath, [config.serverModulePath, "serve"], {
     detached: true,
-    env: process.env,
+    env: daemonEnv(),
     stdio: "ignore",
     windowsHide: true,
   });
@@ -40163,6 +40337,43 @@ async function startNewDaemon() {
   throw new Error("new console daemon did not become healthy");
 }
 
+/**
+ * \uC124\uCE58\uAC00 \uC2E4\uD328\uD55C \uB4A4\uC758 \uB9C8\uC9C0\uB9C9 \uC758\uBB34: \uC5B4\uB5A4 \uBC84\uC804\uC774\uB4E0 \uCF58\uC194\uC744 \uB2E4\uC2DC \uC138\uC6B4\uB2E4. \uC5EC\uAE30\uC11C\uB294 \uBAA9\uD45C \uBC84\uC804\uC744
+ * \uC694\uAD6C\uD558\uC9C0 \uC54A\uB294\uB2E4 \u2014 \uC61B \uBC84\uC804\uC73C\uB85C\uB77C\uB3C4 \uC0B4\uC544 \uC788\uC5B4\uC57C \uC2E4\uD328\uB97C \uC77D\uC744 \uD654\uBA74\uC774 \uC0DD\uAE34\uB2E4.
+ */
+async function recoverConsoleBestEffort() {
+  try {
+    const child = spawn(process.execPath, [config.serverModulePath, "serve"], {
+      detached: true,
+      env: daemonEnv(),
+      stdio: "ignore",
+      windowsHide: true,
+    });
+    child.once("error", () => {});
+    child.unref();
+    const deadline = Date.now() + startTimeoutMs;
+    while (Date.now() < deadline) {
+      const lock = readLock();
+      if (lock && isProcessAlive(lock.pid) && await isAnyHealthOk(lock)) {
+        log("recovered console after failure");
+        return;
+      }
+      await sleep(sleepMs);
+    }
+    log("recovery did not become healthy before timeout");
+  } catch (error) {
+    log("recovery failed: " + sanitizeError(error));
+  }
+}
+
+function isSameEndpoint(left, right) {
+  try {
+    return new URL(left).host === new URL(right).host;
+  } catch {
+    return false;
+  }
+}
+
 function openBrowser(url) {
   const platform = os.platform();
   if (platform === "darwin") {
@@ -40190,6 +40401,18 @@ function spawnExit(command, args) {
   });
 }
 
+/** \uC6B0\uB9AC\uAC00 \uB0B4\uB9B0 pid\uC758 \uB77D\uB9CC \uC9C0\uC6B4\uB2E4 \u2014 \uADF8 \uC0AC\uC774 \uC62C\uB77C\uC628 \uC0C8 \uCF58\uC194\uC758 \uB77D\uC740 \uAC74\uB4DC\uB9AC\uC9C0 \uC54A\uB294\uB2E4. */
+function removeStaleLock() {
+  const lock = readLock();
+  if (!lock || lock.pid !== config.currentPid) return;
+  try {
+    fs.rmSync(config.lockFile, { force: true });
+    log("removed the stale lock of the console we stopped");
+  } catch {
+    // \uC9C0\uC6B0\uC9C0 \uBABB\uD574\uB3C4 \uC0C8 \uB370\uBAAC\uC774 stale lock\uC744 \uC2A4\uC2A4\uB85C \uC815\uB9AC\uD55C\uB2E4.
+  }
+}
+
 function readLock() {
   try {
     return JSON.parse(fs.readFileSync(config.lockFile, "utf8"));
@@ -40216,6 +40439,18 @@ async function isNewHealthOk(lock) {
   }
 }
 
+async function isAnyHealthOk(lock) {
+  if (!lock || typeof lock.endpoint !== "string" || typeof lock.token !== "string") return false;
+  try {
+    const response = await fetch(new URL("api/v1/health", lock.endpoint), {
+      headers: { authorization: "Bearer " + lock.token },
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
 async function readHealthVersion(response) {
   try {
     const payload = await response.json();
@@ -40284,6 +40519,14 @@ function sanitizeError(error) {
 }
 `;
 }
+function readEndpointPort(endpoint) {
+  try {
+    const port = Number.parseInt(new URL(endpoint).port, 10);
+    return Number.isInteger(port) && port > 0 && port < 65536 ? port : null;
+  } catch {
+    return null;
+  }
+}
 function isManagedRuntimePackageRoot(packageRoot) {
   if (path18__default.basename(packageRoot) !== "latest" || path18__default.basename(path18__default.dirname(packageRoot)) !== "console") return false;
   try {
@@ -40446,6 +40689,7 @@ var MIN_CONSOLE_STATIC_PORT2 = 1024;
 var MAX_CONSOLE_STATIC_PORT2 = 65535;
 var SERVER_TIMEOUT_MS = 30 * 60 * 1e3;
 var MAX_BODY_BYTES = 1024 * 1024;
+var DESKTOP_UPDATE_REQUEST_TTL_MS = 6e4;
 var UPDATE_APPLY_FORBIDDEN_BODY_KEYS = /* @__PURE__ */ new Set(["channel", "package", "packageName", "packageVersion", "packages", "targetVersion", "version"]);
 var OPERATION_RENAMED_EVENT_CHANNEL = "operation:renamed";
 var PAIRING_IDENTITY_PATH = "/api/v1/pairing-identity";
@@ -40547,6 +40791,14 @@ var SERVER_API_CATALOG = [
     gate: "origin-write",
     transport: "http"
   },
+  {
+    method: "GET",
+    path: "/api/v1/updates/progress",
+    summary: "Read the outcome of the update this console just came back from.",
+    category: "Update",
+    gate: "loopback",
+    transport: "http"
+  },
   {
     method: "POST",
     path: "/api/v1/updates/apply",
@@ -40694,6 +40946,7 @@ function createConsoleServer(deps = {}) {
   const desktop = readDesktopProtocolEnvironment();
   const version2 = deps.version ?? release.version;
   const channel = release.channel;
+  const resumePort = takeConsoleResumePort(process.env);
   const lock = createConsoleLock({ hostname: () => host });
   const releaseNotes = deps.releaseNotes ?? createConsoleReleaseNotesService();
   const updateCheck = deps.updateCheck ?? createConsoleUpdateCheckService({ readRelease: () => release });
@@ -40760,6 +41013,9 @@ function createConsoleServer(deps = {}) {
   const pluginEventListeners = /* @__PURE__ */ new Map();
   const operationSseSubscribers = /* @__PURE__ */ new Set();
   const desktopThemeSseSubscribers = /* @__PURE__ */ new Set();
+  const desktopUpdateSseSubscribers = /* @__PURE__ */ new Set();
+  let desktopUpdateRequest = emptyDesktopUpdateRequest();
+  let desktopUpdateRequestedAt = 0;
   function publishPluginEvent(channel2, payload) {
     for (const listener of pluginEventListeners.get(channel2) ?? []) listener(payload);
   }
@@ -40970,6 +41226,24 @@ function createConsoleServer(deps = {}) {
       });
     }
   });
+  const desktopUpdateRouter = createDesktopUpdateRouter({
+    getUpdateRequest: () => readDesktopUpdateRequest(),
+    isAuthorized: isExactConsoleOrigin,
+    writeJson,
+    subscribe: (res, snapshot) => {
+      res.writeHead(200, withSecurityHeaders2({
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      }));
+      res.write(":connected\n\n");
+      res.write(encodeSseData(DESKTOP_UPDATE_EVENT, snapshot));
+      desktopUpdateSseSubscribers.add(res);
+      res.on("close", () => {
+        desktopUpdateSseSubscribers.delete(res);
+      });
+    }
+  });
   const desktopShellRouter = createDesktopShellRouter({
     getShell: (req) => {
       const owner = shellOwnerOf(req);
@@ -41070,6 +41344,7 @@ function createConsoleServer(deps = {}) {
   routeRegistry.register("/api/v1/desktop", async (context) => {
     if (await desktopShellRouter(context)) return true;
     if (await desktopFullscreenRouter(context)) return true;
+    if (desktopUpdateRouter(context)) return true;
     return desktopThemeRouter(context);
   });
   routeRegistry.register("/plugin-runtime", handlePluginRuntimeRoute);
@@ -41195,6 +41470,10 @@ function createConsoleServer(deps = {}) {
       runAsyncHandler(handleObserverReleaseNotes(req, res), res);
       return;
     }
+    if (pathname === "/api/v1/updates/progress") {
+      handleUpdateProgress(req, res);
+      return;
+    }
     if (pathname === "/api/v1/updates/apply") {
       runAsyncHandler(handleUpdateApply(req, res), res);
       return;
@@ -41860,6 +42139,19 @@ function createConsoleServer(deps = {}) {
       throw error51;
     }
   }
+  function handleUpdateProgress(req, res) {
+    if (req.method !== "GET") {
+      writeJson(res, 405, { error: "Method not allowed" });
+      return;
+    }
+    let progress;
+    try {
+      progress = readConsoleUpdateProgress(durablePaths.dir);
+    } catch {
+      progress = IDLE_CONSOLE_UPDATE_PROGRESS;
+    }
+    writeJson(res, 200, progress);
+  }
   async function handleUpdateApply(req, res) {
     if (req.method !== "POST") {
       writeJson(res, 405, { error: "Method not allowed" });
@@ -41891,6 +42183,16 @@ function createConsoleServer(deps = {}) {
       writeJson(res, 409, { error: "update_not_available" });
       return;
     }
+    if (!isLoopbackListener(req) && (body2 === null || body2.acknowledgeHostRestart !== true)) {
+      writeJson(res, 409, { error: "host_restart_confirmation_required" });
+      return;
+    }
+    if (isManagedRuntimePackageRoot(release.packageRoot)) {
+      publishDesktopUpdateRequest({ requestedVersion: freshStatus.latestVersion, requestId: crypto5.randomUUID() });
+      const delegated = { status: "delegated" };
+      writeJson(res, 202, delegated);
+      return;
+    }
     const handle = lockHandle;
     if (!handle || !activeEndpoint || !activeLockFile) {
       writeJson(res, 503, { error: "console_not_ready" });
@@ -41903,6 +42205,7 @@ function createConsoleServer(deps = {}) {
         currentPackageRoot: release.packageRoot,
         currentPid: process.pid,
         dataDir: durablePaths.dir,
+        fromVersion: version2,
         lockFile: activeLockFile,
         targetVersion: freshStatus.latestVersion
       });
@@ -41989,7 +42292,7 @@ function createConsoleServer(deps = {}) {
     listeners = [];
     boundPort = null;
     access.revokeAllSessions();
-    if (closingRemote) await new Promise((resolve3) => closingRemote.close(() => resolve3()));
+    await closeHttpServer(closingRemote);
     const cleanupResults = await Promise.allSettled([...pluginCleanupCallbacks].map((cleanup) => cleanup()));
     for (const result of cleanupResults) {
       if (result.status === "rejected") {
@@ -42118,6 +42421,21 @@ function createConsoleServer(deps = {}) {
       res.write(data);
     }
   }
+  function readDesktopUpdateRequest() {
+    if (desktopUpdateRequest.requestId === null) return desktopUpdateRequest;
+    if (Date.now() - desktopUpdateRequestedAt <= DESKTOP_UPDATE_REQUEST_TTL_MS) return desktopUpdateRequest;
+    desktopUpdateRequest = emptyDesktopUpdateRequest();
+    return desktopUpdateRequest;
+  }
+  function publishDesktopUpdateRequest(snapshot) {
+    desktopUpdateRequestedAt = Date.now();
+    desktopUpdateRequest = snapshot;
+    if (desktopUpdateSseSubscribers.size === 0) return;
+    const data = encodeSseData(DESKTOP_UPDATE_EVENT, snapshot);
+    for (const res of desktopUpdateSseSubscribers) {
+      res.write(data);
+    }
+  }
   function persistDurableState() {
     try {
       saveDurableState(deletionCoordinator.list());
@@ -42193,6 +42511,11 @@ function createConsoleServer(deps = {}) {
     }
   };
   function resolveConsolePortListenPlan() {
+    const plan = resolveConfiguredConsolePortListenPlan();
+    if (resumePort === null || plan.portMode !== "dynamic") return plan;
+    return { ...plan, port: resumePort, allowFallback: true };
+  }
+  function resolveConfiguredConsolePortListenPlan() {
     if (deps.port !== void 0) {
       return {
         port,
@@ -42322,7 +42645,7 @@ function createConsoleServer(deps = {}) {
       if (owner !== "local") desktopShellsByOwner.delete(owner);
     }
     broadcastControlChanged();
-    if (closing) await new Promise((resolve3) => closing.close(() => resolve3()));
+    await closeHttpServer(closing);
   }
   async function startRemoteAccessIfEnabled(_actualPort) {
     const configured = consoleSettingsStore.load().general?.remoteAccess;
@@ -42582,6 +42905,14 @@ function isPlainObject2(value) {
 function hasForbiddenUpdateApplyBodyKeys(body2) {
   return Object.keys(body2).some((key) => UPDATE_APPLY_FORBIDDEN_BODY_KEYS.has(key));
 }
+var CONSOLE_RESUME_PORT_ENV = "FLEET_CONSOLE_RESUME_PORT";
+function takeConsoleResumePort(env) {
+  const raw = env[CONSOLE_RESUME_PORT_ENV];
+  delete env[CONSOLE_RESUME_PORT_ENV];
+  if (raw === void 0) return null;
+  const port = Number.parseInt(raw, 10);
+  return Number.isInteger(port) && port > 0 && port < 65536 ? port : null;
+}
 function isValidConsoleStaticPort2(value) {
   return typeof value === "number" && Number.isInteger(value) && value >= MIN_CONSOLE_STATIC_PORT2 && value <= MAX_CONSOLE_STATIC_PORT2;
 }