@askexenow/exe-os 0.9.113 → 0.9.115

package/dist/bin/exe-dispatch.js

@@ -447,6 +447,17 @@ function normalizeOrchestration(raw) {
   const userOrg = raw.orchestration ?? {};
   raw.orchestration = { ...defaultOrg, ...userOrg };
 }
+function normalizeCloudEndpoint(raw) {
+  const cloud = raw.cloud;
+  if (!cloud?.endpoint) return;
+  const ep = String(cloud.endpoint);
+  if (ep === "https://askexe.com/cloud" || ep === "https://askexe.com/cloud/") {
+    cloud.endpoint = "https://cloud.askexe.com";
+    process.stderr.write(
+      "[config] Auto-migrated cloud endpoint: askexe.com/cloud \u2192 cloud.askexe.com\n"
+    );
+  }
+}
 async function loadConfig() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
   await ensurePrivateDir(dir);
@@ -472,6 +483,7 @@ async function loadConfig() {
     normalizeSessionLifecycle(migratedCfg);
     normalizeAutoUpdate(migratedCfg);
     normalizeOrchestration(migratedCfg);
+    normalizeCloudEndpoint(migratedCfg);
     const config = { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db"), ...migratedCfg };
     if (config.dbPath.startsWith("~")) {
       config.dbPath = config.dbPath.replace(/^~/, os2.homedir());
@@ -500,6 +512,7 @@ function loadConfigSync() {
     normalizeSessionLifecycle(migratedCfg);
     normalizeAutoUpdate(migratedCfg);
     normalizeOrchestration(migratedCfg);
+    normalizeCloudEndpoint(migratedCfg);
     const config = { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db"), ...migratedCfg };
     if (config.dbPath.startsWith("~")) {
       config.dbPath = config.dbPath.replace(/^~/, os2.homedir());
@@ -660,6 +673,7 @@ __export(agent_config_exports, {
   clearAgentRuntime: () => clearAgentRuntime,
   getAgentRuntime: () => getAgentRuntime,
   loadAgentConfig: () => loadAgentConfig,
+  normalizeCcModelName: () => normalizeCcModelName,
   saveAgentConfig: () => saveAgentConfig,
   setAgentMcps: () => setAgentMcps,
   setAgentRuntime: () => setAgentRuntime
@@ -688,6 +702,13 @@ function getAgentRuntime(agentId) {
   if (orgDefault) return orgDefault;
   return { runtime: DEFAULT_RUNTIME, model: DEFAULT_MODELS[DEFAULT_RUNTIME] };
 }
+function normalizeCcModelName(model) {
+  let ccModel = model.replace(/(\d+)\.(\d+)/g, "$1-$2");
+  if (/claude-(opus|sonnet)-4-[6-9]/.test(ccModel) && !ccModel.includes("[1m]")) {
+    ccModel += "[1m]";
+  }
+  return ccModel;
+}
 function setAgentRuntime(agentId, runtime, model, reasoning_effort, mcps) {
   const knownModels = KNOWN_RUNTIMES[runtime];
   if (!knownModels) {
@@ -757,6 +778,7 @@ var init_agent_config = __esm({
 // src/lib/intercom-queue.ts
 var intercom_queue_exports = {};
 __export(intercom_queue_exports, {
+  _resetDrainGuard: () => _resetDrainGuard,
   clearQueueForAgent: () => clearQueueForAgent,
   drainForSession: () => drainForSession,
   drainQueue: () => drainQueue,
@@ -802,38 +824,47 @@ function queueIntercom(targetSession, reason) {
   writeQueue(queue);
 }
 function drainQueue(isSessionBusy2, sendKeys) {
+  if (_draining) {
+    logQueue("SKIP_DRAIN \u2014 previous drain still running (possible tmux hang)");
+    return { drained: 0, failed: 0 };
+  }
   const queue = readQueue();
   if (queue.length === 0) return { drained: 0, failed: 0 };
+  _draining = true;
   const remaining = [];
   let drained = 0;
   let failed = 0;
-  for (const item of queue) {
-    const age = Date.now() - new Date(item.queuedAt).getTime();
-    if (age > TTL_MS) {
-      logQueue(`EXPIRED \u2192 ${item.targetSession} (${Math.round(age / 6e4)}min old, reason: ${item.reason})`);
-      failed++;
-      continue;
-    }
-    try {
-      if (!isSessionBusy2(item.targetSession)) {
-        const success = sendKeys(item.targetSession);
-        if (success) {
-          logQueue(`DRAINED \u2192 ${item.targetSession} (after ${item.attempts} retries)`);
-          drained++;
-          continue;
+  try {
+    for (const item of queue) {
+      const age = Date.now() - new Date(item.queuedAt).getTime();
+      if (age > TTL_MS) {
+        logQueue(`EXPIRED \u2192 ${item.targetSession} (${Math.round(age / 6e4)}min old, reason: ${item.reason})`);
+        failed++;
+        continue;
+      }
+      try {
+        if (!isSessionBusy2(item.targetSession)) {
+          const success = sendKeys(item.targetSession);
+          if (success) {
+            logQueue(`DRAINED \u2192 ${item.targetSession} (after ${item.attempts} retries)`);
+            drained++;
+            continue;
+          }
         }
+      } catch {
       }
-    } catch {
-    }
-    item.attempts++;
-    if (item.attempts >= MAX_RETRIES) {
-      logQueue(`FAILED \u2192 ${item.targetSession} (${MAX_RETRIES} retries exhausted, reason: ${item.reason})`);
-      failed++;
-      continue;
+      item.attempts++;
+      if (item.attempts >= MAX_RETRIES) {
+        logQueue(`FAILED \u2192 ${item.targetSession} (${MAX_RETRIES} retries exhausted, reason: ${item.reason})`);
+        failed++;
+        continue;
+      }
+      remaining.push(item);
     }
-    remaining.push(item);
+    writeQueue(remaining);
+  } finally {
+    _draining = false;
   }
-  writeQueue(remaining);
   return { drained, failed };
 }
 function drainForSession(targetSession, sendKeys) {
@@ -858,6 +889,9 @@ function clearQueueForAgent(agentName) {
     logQueue(`CLEARED ${before - filtered.length} stale item(s) for ${agentName}`);
   }
 }
+function _resetDrainGuard() {
+  _draining = false;
+}
 function logQueue(msg) {
   const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [queue] ${msg}
 `;
@@ -869,13 +903,14 @@ function logQueue(msg) {
   } catch {
   }
 }
-var QUEUE_PATH, MAX_RETRIES, TTL_MS, INTERCOM_LOG;
+var QUEUE_PATH, MAX_RETRIES, TTL_MS, _draining, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
     QUEUE_PATH = path4.join(os3.homedir(), ".exe-os", "intercom-queue.json");
     MAX_RETRIES = 5;
     TTL_MS = 60 * 60 * 1e3;
+    _draining = false;
     INTERCOM_LOG = path4.join(os3.homedir(), ".exe-os", "intercom.log");
   }
 });
@@ -4802,6 +4837,17 @@ var init_task_scope = __esm({
 });
 
 // src/lib/notifications.ts
+var notifications_exports = {};
+__export(notifications_exports, {
+  cleanupOldNotifications: () => cleanupOldNotifications,
+  formatNotifications: () => formatNotifications,
+  markAsRead: () => markAsRead,
+  markAsReadByTaskFile: () => markAsReadByTaskFile,
+  markDoneTaskNotificationsAsRead: () => markDoneTaskNotificationsAsRead,
+  migrateJsonNotifications: () => migrateJsonNotifications,
+  readUnreadNotifications: () => readUnreadNotifications,
+  writeNotification: () => writeNotification
+});
 import crypto2 from "crypto";
 import path12 from "path";
 import os9 from "os";
@@ -4838,6 +4884,52 @@ async function writeNotification(notification) {
 `);
   }
 }
+async function readUnreadNotifications(agentFilter, sessionScope) {
+  try {
+    const client = getClient();
+    const conditions = ["read = 0"];
+    const args = [];
+    const scope = strictSessionScopeFilter(sessionScope);
+    if (agentFilter) {
+      conditions.push("agent_id = ?");
+      args.push(agentFilter);
+    }
+    const result2 = await client.execute({
+      sql: `SELECT id, agent_id, agent_role, event, project, summary, task_file, session_scope, created_at
+            FROM notifications
+            WHERE ${conditions.join(" AND ")}${scope.sql}
+            ORDER BY created_at ASC`,
+      args: [...args, ...scope.args]
+    });
+    return result2.rows.map((r) => ({
+      id: String(r.id),
+      agentId: String(r.agent_id),
+      agentRole: String(r.agent_role),
+      event: String(r.event),
+      project: String(r.project),
+      summary: String(r.summary),
+      taskFile: r.task_file ? String(r.task_file) : void 0,
+      sessionScope: r.session_scope == null ? null : String(r.session_scope),
+      timestamp: String(r.created_at),
+      read: false
+    }));
+  } catch {
+    return [];
+  }
+}
+async function markAsRead(ids, sessionScope) {
+  if (ids.length === 0) return;
+  try {
+    const client = getClient();
+    const placeholders = ids.map(() => "?").join(", ");
+    const scope = strictSessionScopeFilter(sessionScope);
+    await client.execute({
+      sql: `UPDATE notifications SET read = 1 WHERE id IN (${placeholders})${scope.sql}`,
+      args: [...ids, ...scope.args]
+    });
+  } catch {
+  }
+}
 async function markAsReadByTaskFile(taskFile, sessionScope) {
   try {
     const client = getClient();
@@ -4850,11 +4942,144 @@ async function markAsReadByTaskFile(taskFile, sessionScope) {
   } catch {
   }
 }
+async function cleanupOldNotifications(daysOld = CLEANUP_DAYS, sessionScope) {
+  try {
+    const client = getClient();
+    const cutoff = new Date(
+      Date.now() - daysOld * 24 * 60 * 60 * 1e3
+    ).toISOString();
+    const scope = strictSessionScopeFilter(sessionScope);
+    const result2 = await client.execute({
+      sql: `DELETE FROM notifications WHERE created_at < ?${scope.sql}`,
+      args: [cutoff, ...scope.args]
+    });
+    return result2.rowsAffected;
+  } catch {
+    return 0;
+  }
+}
+async function markDoneTaskNotificationsAsRead(sessionScope) {
+  try {
+    const client = getClient();
+    const scope = strictSessionScopeFilter(sessionScope);
+    const result2 = await client.execute({
+      sql: `UPDATE notifications SET read = 1
+            WHERE read = 0
+              AND task_file IS NOT NULL
+              ${scope.sql}
+              AND task_file IN (
+                SELECT task_file FROM tasks WHERE status = 'done'${scope.sql}
+              )`,
+      args: [...scope.args, ...scope.args]
+    });
+    return result2.rowsAffected;
+  } catch {
+    return 0;
+  }
+}
+function formatNotifications(notifications) {
+  if (notifications.length === 0) return "";
+  const grouped = /* @__PURE__ */ new Map();
+  for (const n of notifications) {
+    const key = `${n.agentId}|${n.agentRole}`;
+    if (!grouped.has(key)) grouped.set(key, []);
+    grouped.get(key).push(n);
+  }
+  const lines = [];
+  lines.push(`## Notifications (${notifications.length} unread)
+`);
+  for (const [key, items] of grouped) {
+    const [agentId, agentRole] = key.split("|");
+    lines.push(`**${agentId}** (${agentRole}):`);
+    for (const item of items) {
+      const ago = formatTimeAgo(item.timestamp);
+      const icon = eventIcon(item.event);
+      lines.push(`- ${icon} ${item.summary} (${item.project}) \u2014 ${ago}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function migrateJsonNotifications() {
+  const base = process.env.EXE_OS_DIR || process.env.EXE_MEM_DIR || path12.join(os9.homedir(), ".exe-os");
+  const notifDir = path12.join(base, "notifications");
+  if (!existsSync13(notifDir)) return 0;
+  let migrated = 0;
+  try {
+    const files = readdirSync(notifDir).filter((f) => f.endsWith(".json"));
+    if (files.length === 0) return 0;
+    const client = getClient();
+    for (const file of files) {
+      try {
+        const filePath = path12.join(notifDir, file);
+        const data = JSON.parse(readFileSync10(filePath, "utf8"));
+        await client.execute({
+          sql: `INSERT OR IGNORE INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, session_scope, read, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          args: [
+            crypto2.randomUUID(),
+            data.agentId ?? "unknown",
+            data.agentRole ?? "unknown",
+            data.event ?? "session_summary",
+            data.project ?? "unknown",
+            data.summary ?? "",
+            data.taskFile ?? null,
+            null,
+            data.read ? 1 : 0,
+            data.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+          ]
+        });
+        unlinkSync4(filePath);
+        migrated++;
+      } catch {
+      }
+    }
+    try {
+      const remaining = readdirSync(notifDir);
+      if (remaining.length === 0) {
+        rmdirSync(notifDir);
+      }
+    } catch {
+    }
+  } catch {
+  }
+  return migrated;
+}
+function eventIcon(event) {
+  switch (event) {
+    case "task_complete":
+      return "Completed:";
+    case "task_needs_fix":
+      return "Needs fix:";
+    case "session_summary":
+      return "Session:";
+    case "error_spike":
+      return "Errors:";
+    case "orphan_task":
+      return "Orphan:";
+    case "subtasks_complete":
+      return "Subtasks done:";
+    case "capacity_relaunch":
+      return "Relaunched:";
+  }
+}
+function formatTimeAgo(timestamp) {
+  const diffMs = Date.now() - new Date(timestamp).getTime();
+  const mins = Math.floor(diffMs / 6e4);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+var CLEANUP_DAYS;
 var init_notifications = __esm({
   "src/lib/notifications.ts"() {
     "use strict";
     init_database();
     init_task_scope();
+    CLEANUP_DAYS = 7;
   }
 });
 
@@ -5900,7 +6125,13 @@ async function createReviewForCompletedTask(row, result2, _baseDir, now) {
     taskFile
   });
   const originalPriority = String(row.priority).toLowerCase();
-  const autoApprove = originalPriority === "p2" && result2?.toLowerCase().includes("tests pass");
+  const resultLower = result2?.toLowerCase() ?? "";
+  const hasTestEvidence = (
+    // Vitest/Jest output patterns (hard to fake without actually running tests)
+    /\d+\s+pass(ed|ing)/.test(resultLower) || /test files?\s+\d+\s+passed/.test(resultLower) || /tests?\s+\d+\s+passed/.test(resultLower)
+  );
+  const hasNoFailures = !/fail(ed|ure|ing)|error/i.test(resultLower);
+  const autoApprove = originalPriority === "p2" && hasTestEvidence && hasNoFailures;
   if (!autoApprove) {
     try {
       const key = getSessionKey();
@@ -5908,6 +6139,13 @@ async function createReviewForCompletedTask(row, result2, _baseDir, now) {
       if (exeSession2) {
         sendIntercom(exeSession2);
       }
+      if (reviewer && reviewer !== coordinatorName && reviewer !== exeSession2) {
+        const { employeeSessionName: employeeSessionName2 } = await Promise.resolve().then(() => (init_tmux_routing(), tmux_routing_exports));
+        if (exeSession2) {
+          const reviewerSession = employeeSessionName2(reviewer, exeSession2);
+          sendIntercom(reviewerSession);
+        }
+      }
     } catch {
     }
   }
@@ -6683,6 +6921,20 @@ async function updateTask(input) {
       notifyTaskDone();
     }
     await markTaskNotificationsRead(taskFile);
+    if (input.status === "needs_review" && !isCoordinator) {
+      try {
+        const { writeNotification: writeNotification2 } = await Promise.resolve().then(() => (init_notifications(), notifications_exports));
+        await writeNotification2({
+          agentId: String(row.assigned_to),
+          agentRole: String(row.assigned_to),
+          event: "task_complete",
+          project: String(row.project_name),
+          summary: `"${String(row.title)}" is ready for review`,
+          taskFile
+        });
+      } catch {
+      }
+    }
     if (input.status === "done" || input.status === "closed") {
       try {
         await cascadeUnblock(taskId, input.baseDir, now);
@@ -7115,18 +7367,31 @@ function acquireSpawnLock2(sessionName) {
     mkdirSync8(SPAWN_LOCK_DIR, { recursive: true });
   }
   const lockFile = spawnLockPath(sessionName);
-  if (existsSync16(lockFile)) {
-    try {
-      const lock = JSON.parse(readFileSync12(lockFile, "utf8"));
-      const age = Date.now() - lock.timestamp;
-      if (isProcessAlive(lock.pid) && age < 6e4) {
-        return false;
-      }
-    } catch {
+  const lockData = JSON.stringify({ pid: process.pid, timestamp: Date.now() });
+  const { openSync: openSync3, closeSync: closeSync3, writeSync } = __require("fs");
+  const { constants } = __require("fs");
+  try {
+    const fd = openSync3(lockFile, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 420);
+    writeSync(fd, lockData);
+    closeSync3(fd);
+    return true;
+  } catch (err) {
+    if (err?.code !== "EEXIST") {
+      return true;
     }
   }
-  writeFileSync8(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
-  return true;
+  try {
+    const lock = JSON.parse(readFileSync12(lockFile, "utf8"));
+    const age = Date.now() - lock.timestamp;
+    if (isProcessAlive(lock.pid) && age < 6e4) {
+      return false;
+    }
+    writeFileSync8(lockFile, lockData);
+    return true;
+  } catch {
+    writeFileSync8(lockFile, lockData);
+    return true;
+  }
 }
 function releaseSpawnLock2(sessionName) {
   try {
@@ -7205,6 +7470,21 @@ function parseParentExe(sessionName, agentId) {
 function extractRootExe(name) {
   if (!name) return null;
   if (!name.includes("-")) return name;
+  try {
+    const roster = (init_employees(), __toCommonJS(employees_exports)).loadEmployeesSync();
+    if (roster.length > 0) {
+      const sortedNames = roster.map((e) => e.name).sort((a, b) => b.length - a.length);
+      for (const agentName of sortedNames) {
+        const escaped = agentName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const regex = new RegExp(`^${escaped}\\d*-(.+)$`);
+        const match = name.match(regex);
+        if (match) {
+          return extractRootExe(match[1]);
+        }
+      }
+    }
+  } catch {
+  }
   const parts = name.split("-").filter(Boolean);
   return parts.length > 0 ? parts[parts.length - 1] : null;
 }
@@ -7223,6 +7503,10 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
 function getParentExe(sessionKey) {
   try {
     const data = JSON.parse(readFileSync12(path18.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    if (data.registeredAt) {
+      const age = Date.now() - new Date(data.registeredAt).getTime();
+      if (age > PARENT_EXE_CACHE_TTL_MS) return null;
+    }
     return data.parentExe || null;
   } catch {
     return null;
@@ -7771,7 +8055,7 @@ function spawnEmployee(employeeName2, exeSession2, projectDir2, opts) {
     sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
   } catch {
   }
-  let envPrefix = `EXE_SESSION=${exeSession2} EXE_SESSION_NAME=${sessionName}`;
+  let envPrefix = `EXE_SESSION=${exeSession2} EXE_SESSION_NAME=${sessionName} EXE_SESSION_START_ISO=${(/* @__PURE__ */ new Date()).toISOString()}`;
   if (ccProvider !== DEFAULT_PROVIDER) {
     const cfg = PROVIDER_TABLE[ccProvider];
     if (cfg?.apiKeyEnv) {
@@ -7806,10 +8090,8 @@ function spawnEmployee(employeeName2, exeSession2, projectDir2, opts) {
   }
   if (!useExeAgent && !useCodex && !useOpencode && !useBinSymlink) {
     if (agentRtConfig.runtime === "claude" && agentRtConfig.model) {
-      let ccModel = agentRtConfig.model.replace(/(\d+)\.(\d+)/g, "$1-$2");
-      if (/claude-(opus|sonnet)-4-[6-9]/.test(ccModel) && !ccModel.includes("[1m]")) {
-        ccModel += "[1m]";
-      }
+      const { normalizeCcModelName: normalizeCcModelName2 } = (init_agent_config(), __toCommonJS(agent_config_exports));
+      const ccModel = normalizeCcModelName2(agentRtConfig.model);
       envPrefix = `${envPrefix} ANTHROPIC_MODEL=${ccModel}`;
     }
   }
@@ -7910,7 +8192,7 @@ function spawnEmployee(employeeName2, exeSession2, projectDir2, opts) {
   releaseSpawnLock2(sessionName);
   return { sessionName };
 }
-var SPAWN_LOCK_DIR, SESSION_CACHE, BEHAVIORS_EXPORT_TIMEOUT_MS, VALID_SESSION_NAME, VERIFY_PANE_LINES, INTERCOM_DEBOUNCE_MS, CODEX_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN;
+var SPAWN_LOCK_DIR, SESSION_CACHE, BEHAVIORS_EXPORT_TIMEOUT_MS, VALID_SESSION_NAME, PARENT_EXE_CACHE_TTL_MS, VERIFY_PANE_LINES, INTERCOM_DEBOUNCE_MS, CODEX_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN;
 var init_tmux_routing = __esm({
   "src/lib/tmux-routing.ts"() {
     "use strict";
@@ -7930,6 +8212,7 @@ var init_tmux_routing = __esm({
     SESSION_CACHE = path18.join(os11.homedir(), ".exe-os", "session-cache");
     BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
     VALID_SESSION_NAME = /^[a-z]+\d*-[a-zA-Z0-9_]+$/;
+    PARENT_EXE_CACHE_TTL_MS = 4 * 60 * 60 * 1e3;
     VERIFY_PANE_LINES = 200;
     INTERCOM_DEBOUNCE_MS = 3e4;
     CODEX_DEBOUNCE_MS = 12e4;
@@ -7941,7 +8224,7 @@ var init_tmux_routing = __esm({
 });
 
 // src/lib/keychain.ts
-import { readFile as readFile4, writeFile as writeFile5, unlink, mkdir as mkdir4, chmod as chmod2 } from "fs/promises";
+import { readFile as readFile4, writeFile as writeFile5, unlink, mkdir as mkdir4, chmod as chmod2, rename, copyFile } from "fs/promises";
 import { existsSync as existsSync17, statSync as statSync3 } from "fs";
 import { execSync as execSync8 } from "child_process";
 import path19 from "path";
@@ -7976,12 +8259,14 @@ function linuxSecretAvailable() {
 function isRootOnlyTrustedServerKeyFile(keyPath) {
   if (process.platform !== "linux") return false;
   try {
-    const uid = typeof os12.userInfo().uid === "number" ? os12.userInfo().uid : -1;
     const st = statSync3(keyPath);
     if (!st.isFile() || (st.mode & 63) !== 0) return false;
+    const uid = typeof os12.userInfo().uid === "number" ? os12.userInfo().uid : -1;
     if (uid === 0) return true;
     const exeOsDir = process.env.EXE_OS_DIR;
-    return Boolean(exeOsDir && path19.resolve(keyPath).startsWith(path19.resolve(exeOsDir) + path19.sep));
+    if (exeOsDir && path19.resolve(keyPath).startsWith(path19.resolve(exeOsDir) + path19.sep)) return true;
+    if (!linuxSecretAvailable()) return true;
+    return false;
   } catch {
     return false;
   }
@@ -8131,15 +8416,25 @@ async function writeMachineBoundFileFallback(b64) {
   await mkdir4(dir, { recursive: true });
   const keyPath = getKeyPath();
   const machineKey = deriveMachineKey();
-  if (machineKey) {
-    const encrypted = encryptWithMachineKey(b64, machineKey);
-    await writeFile5(keyPath, encrypted + "\n", "utf-8");
-    await chmod2(keyPath, 384);
-    return "encrypted";
+  const content = machineKey ? encryptWithMachineKey(b64, machineKey) + "\n" : b64 + "\n";
+  const result2 = machineKey ? "encrypted" : "plaintext";
+  const tmpPath = keyPath + ".tmp";
+  try {
+    if (existsSync17(keyPath)) {
+      await copyFile(keyPath, keyPath + ".bak").catch(() => {
+      });
+    }
+    await writeFile5(tmpPath, content, "utf-8");
+    await chmod2(tmpPath, 384);
+    await rename(tmpPath, keyPath);
+  } catch (err) {
+    try {
+      await unlink(tmpPath);
+    } catch {
+    }
+    throw err;
   }
-  await writeFile5(keyPath, b64 + "\n", "utf-8");
-  await chmod2(keyPath, 384);
-  return "plaintext";
+  return result2;
 }
 async function getMasterKey() {
   let nativeValue = macKeychainGet() ?? linuxSecretGet();
@@ -8206,7 +8501,7 @@ async function getMasterKey() {
       b64Value = content;
     }
     const key = Buffer.from(b64Value, "base64");
-    if (!content.startsWith(ENCRYPTED_PREFIX) && isRootOnlyTrustedServerKeyFile(keyPath)) {
+    if (isRootOnlyTrustedServerKeyFile(keyPath)) {
       return key;
     }
     const migrated = macKeychainSet(b64Value) || linuxSecretSet(b64Value);