codexuse-cli 6.0.1 → 6.0.3

package/dist/index.js

@@ -2026,7 +2026,7 @@ var require_toml = __commonJS({
 });
 
 // src/commands/accountPool.ts
-var import_node_crypto12 = require("crypto");
+var import_node_crypto13 = require("crypto");
 var import_node_path13 = __toESM(require("path"));
 
 // ../../packages/contracts/src/settings/types.ts
@@ -2078,8 +2078,8 @@ function migrateLegacyAccountPoolExposedReasoningDefaults(efforts) {
 
 // ../../packages/runtime-app-state/src/app/state.ts
 var import_node_async_hooks = require("async_hooks");
-var import_node_crypto = require("crypto");
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_crypto2 = require("crypto");
+var import_node_path3 = __toESM(require("path"), 1);
 var import_node_os = __toESM(require("os"), 1);
 
 // ../../packages/contracts/src/settings/auto-roll.ts
@@ -2211,16 +2211,98 @@ function normalizeAutoRollSettings(raw) {
 }
 
 // ../../packages/runtime-app-state/src/storage/documents.ts
+var import_node_fs2 = require("fs");
+var import_node_fs3 = require("fs");
+var import_node_crypto = require("crypto");
+var import_node_path2 = __toESM(require("path"), 1);
+
+// ../../packages/runtime-app-state/src/storage/fileLock.ts
 var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"), 1);
+function isSqliteBusyError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const value3 = error;
+  if (value3.cause && value3.cause !== error && isSqliteBusyError(value3.cause)) {
+    return true;
+  }
+  if (value3.error && value3.error !== error && isSqliteBusyError(value3.error)) {
+    return true;
+  }
+  const message = typeof value3.message === "string" ? value3.message.toLowerCase() : String(error).toLowerCase();
+  return value3.code === "SQLITE_BUSY" || value3.errno === 5 || message.includes("sqlite_busy") || message.includes("database is locked");
+}
+async function openLockDatabase(databasePath) {
+  await import_node_fs.promises.mkdir(import_node_path.default.dirname(databasePath), { recursive: true, mode: 448 });
+  const sqlite = process.versions.bun ? await Function("return import('bun:sqlite')")() : await Function("return import('node:sqlite')")();
+  const database = process.versions.bun ? new sqlite.Database(databasePath) : new sqlite.DatabaseSync(databasePath);
+  try {
+    if (process.platform !== "win32") {
+      await import_node_fs.promises.chmod(databasePath, 384);
+    }
+    return {
+      exec: database.exec.bind(database),
+      close: database.close.bind(database)
+    };
+  } catch (error) {
+    database.close();
+    throw error;
+  }
+}
+async function acquireCrossProcessFileLockTransaction(filePath, mode) {
+  const databasePath = `${import_node_path.default.resolve(filePath)}.codexuse-lock.sqlite`;
+  let database = null;
+  try {
+    database = await openLockDatabase(databasePath);
+    database.exec(`PRAGMA busy_timeout = ${mode === "write" ? 1e3 : 0};`);
+    database.exec("CREATE TABLE IF NOT EXISTS codexuse_file_lock (id INTEGER PRIMARY KEY);");
+    if (mode === "write") {
+      database.exec("BEGIN EXCLUSIVE;");
+    } else {
+      database.exec("BEGIN;");
+      database.exec("SELECT COUNT(*) FROM codexuse_file_lock;");
+    }
+  } catch (error) {
+    database?.close();
+    if (isSqliteBusyError(error)) {
+      return null;
+    }
+    throw error;
+  }
+  const acquiredDatabase = database;
+  let released = false;
+  return async () => {
+    if (released) {
+      return;
+    }
+    released = true;
+    try {
+      acquiredDatabase.exec("ROLLBACK;");
+    } finally {
+      acquiredDatabase.close();
+    }
+  };
+}
+async function acquireCrossProcessFileLock(filePath) {
+  return acquireCrossProcessFileLockTransaction(filePath, "write");
+}
+async function acquireCrossProcessFileReadLock(filePath) {
+  return acquireCrossProcessFileLockTransaction(filePath, "read");
+}
+
+// ../../packages/runtime-app-state/src/storage/documents.ts
 var APP_STORAGE_TABLE = "app_storage_documents";
 var APP_STORAGE_DB_DIR = "app-state";
 var APP_STORAGE_DB_NAME = "state.sqlite";
+var APP_STORAGE_QUARANTINE_DIR = "quarantine";
+var APP_STORAGE_RECOVERY_LOG_LIMIT = 50;
+var APP_STORAGE_QUARANTINE_LIMIT = 3;
 var SQLITE_BUSY_TIMEOUT_MS = 5e3;
 var SQLITE_BUSY_MAX_ATTEMPTS = 3;
 var SQLITE_BUSY_RETRY_DELAY_MS = 100;
 var writeQueueByDbPath = /* @__PURE__ */ new Map();
-var initializedDbPaths = /* @__PURE__ */ new Set();
+var databaseRecoveryByDbPath = /* @__PURE__ */ new Map();
 var AppStorageCorruptionError = class extends Error {
   constructor(message, options) {
     super(message);
@@ -2232,6 +2314,13 @@ var AppStorageCorruptionError = class extends Error {
     }
   }
 };
+var recoveryLog = [];
+function recordRecovery(event) {
+  recoveryLog.push(event);
+  if (recoveryLog.length > APP_STORAGE_RECOVERY_LOG_LIMIT) {
+    recoveryLog.splice(0, recoveryLog.length - APP_STORAGE_RECOVERY_LOG_LIMIT);
+  }
+}
 function isRecord(value3) {
   return Boolean(value3) && typeof value3 === "object" && !Array.isArray(value3);
 }
@@ -2251,53 +2340,239 @@ function safeParseJson(raw) {
     return null;
   }
 }
-function parseJsonStrict(raw, options) {
-  if (typeof raw !== "string" || raw.trim().length === 0) {
-    return null;
-  }
-  try {
-    return JSON.parse(raw);
-  } catch (error) {
-    throw new AppStorageCorruptionError(
-      `App storage document ${options.namespace} contains invalid JSON.`,
-      {
-        dbPath: options.dbPath,
-        namespace: options.namespace,
-        cause: error
-      }
-    );
-  }
+function describeError(error) {
+  return error instanceof Error ? error.message : String(error);
 }
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-function isSqliteBusyError(error) {
+function matchesErrorChain(error, predicate) {
   if (!error || typeof error !== "object") {
     return false;
   }
-  const sqliteError = error;
-  if (sqliteError.cause && sqliteError.cause !== error && isSqliteBusyError(sqliteError.cause)) {
+  const candidate = error;
+  if (predicate(candidate)) {
     return true;
   }
-  if (sqliteError.error && sqliteError.error !== error && isSqliteBusyError(sqliteError.error)) {
-    return true;
+  for (const key of ["cause", "error"]) {
+    const nested = candidate[key];
+    if (nested && nested !== error && matchesErrorChain(nested, predicate)) {
+      return true;
+    }
   }
-  const message = typeof sqliteError.message === "string" ? sqliteError.message.toLowerCase() : String(error).toLowerCase();
-  return sqliteError.code === "SQLITE_BUSY" || sqliteError.errno === 5 || message.includes("sqlite_busy") || message.includes("database is locked");
+  return false;
+}
+function isSqliteBusyError2(error) {
+  return matchesErrorChain(error, (candidate) => {
+    const message = typeof candidate.message === "string" ? candidate.message.toLowerCase() : "";
+    return candidate.code === "SQLITE_BUSY" || candidate.errno === 5 || message.includes("sqlite_busy") || message.includes("database is locked");
+  });
 }
 function isSqliteCorruptionError(error) {
-  if (!error || typeof error !== "object") {
-    return false;
+  return matchesErrorChain(error, (candidate) => {
+    const message = typeof candidate.message === "string" ? candidate.message.toLowerCase() : "";
+    return candidate.code === "SQLITE_CORRUPT" || candidate.code === "SQLITE_NOTADB" || candidate.errno === 11 || candidate.errno === 26 || message.includes("database disk image is malformed") || message.includes("file is not a database") || message.includes("database corruption") || message.includes("sqlite_corrupt") || message.includes("sqlite_notadb");
+  });
+}
+function isSqliteCantOpenError(error) {
+  return matchesErrorChain(error, (candidate) => {
+    const message = typeof candidate.message === "string" ? candidate.message.toLowerCase() : "";
+    return candidate.code === "SQLITE_CANTOPEN" || message.includes("unable to open database file");
+  });
+}
+var STORAGE_UNAVAILABLE_CODES = /* @__PURE__ */ new Set([
+  "EACCES",
+  "EPERM",
+  "EROFS",
+  "ENOSPC",
+  "ENOTDIR",
+  "ENAMETOOLONG",
+  "ENOENT",
+  "ELOOP",
+  "EIO",
+  "EMFILE",
+  "ENFILE"
+]);
+function isStorageUnavailableError(error) {
+  return matchesErrorChain(error, (candidate) => {
+    const message = typeof candidate.message === "string" ? candidate.message.toLowerCase() : "";
+    return typeof candidate.code === "string" && (STORAGE_UNAVAILABLE_CODES.has(candidate.code) || candidate.code === "SQLITE_READONLY" || candidate.code === "SQLITE_CANTOPEN") || candidate.errno === 8 || message.includes("attempt to write a readonly database") || message.includes("unable to open database file");
+  });
+}
+function isAppStorageCorruptionError(error) {
+  return error instanceof AppStorageCorruptionError || isSqliteCorruptionError(error);
+}
+function classifyAppStorageFailure(error) {
+  if (isAppStorageCorruptionError(error)) {
+    return "corrupt";
   }
-  const sqliteError = error;
-  if (sqliteError.cause && sqliteError.cause !== error && isSqliteCorruptionError(sqliteError.cause)) {
-    return true;
+  if (isSqliteBusyError2(error)) {
+    return "busy";
   }
-  if (sqliteError.error && sqliteError.error !== error && isSqliteCorruptionError(sqliteError.error)) {
-    return true;
+  if (isStorageUnavailableError(error)) {
+    return "unavailable";
+  }
+  return "unknown";
+}
+function quarantineDirFor(dbPath) {
+  return import_node_path2.default.join(import_node_path2.default.dirname(dbPath), APP_STORAGE_QUARANTINE_DIR);
+}
+function safeFileNamePart(value3) {
+  const cleaned = value3.replace(/[^A-Za-z0-9._-]+/g, "_").slice(0, 80);
+  return cleaned.length > 0 ? cleaned : "unknown";
+}
+function quarantineKey(scope2, value3) {
+  const digest = (0, import_node_crypto.createHash)("sha256").update(value3).digest("hex").slice(0, 10);
+  return `${scope2}-${safeFileNamePart(value3)}-${digest}`;
+}
+function uniqueQuarantinePath(dir, key, extension) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return import_node_path2.default.join(dir, `${key}-${stamp}-${(0, import_node_crypto.randomUUID)()}${extension}`);
+}
+async function pruneQuarantineCopies(input) {
+  try {
+    const prefix = `${input.key}-`;
+    const names = (await import_node_fs3.promises.readdir(input.dir)).filter((name) => {
+      if (name.startsWith(prefix) && name.endsWith(input.extension)) {
+        return true;
+      }
+      if (!input.legacyPrefix || !name.startsWith(input.legacyPrefix)) {
+        return false;
+      }
+      return input.databaseSidecars ? !name.endsWith("-wal") && !name.endsWith("-shm") : name.endsWith(input.extension);
+    });
+    const copies = await Promise.all(names.map(async (name) => ({
+      name,
+      modifiedAt: (await import_node_fs3.promises.stat(import_node_path2.default.join(input.dir, name))).mtimeMs
+    })));
+    copies.sort(
+      (left, right) => right.modifiedAt - left.modifiedAt || right.name.localeCompare(left.name)
+    );
+    for (const { name } of copies.slice(APP_STORAGE_QUARANTINE_LIMIT)) {
+      const candidate = import_node_path2.default.join(input.dir, name);
+      await import_node_fs3.promises.rm(candidate, { force: true });
+      if (input.databaseSidecars) {
+        await Promise.all([
+          import_node_fs3.promises.rm(`${candidate}-wal`, { force: true }),
+          import_node_fs3.promises.rm(`${candidate}-shm`, { force: true })
+        ]);
+      }
+    }
+  } catch {
+  }
+}
+function stageDamagedDocumentRecovery(input) {
+  let backupPath = null;
+  const key = quarantineKey("document", input.namespace);
+  try {
+    const dir = quarantineDirFor(input.dbPath);
+    (0, import_node_fs2.mkdirSync)(dir, { recursive: true, mode: 448 });
+    if (process.platform !== "win32") {
+      (0, import_node_fs2.chmodSync)(dir, 448);
+    }
+    const candidate = uniqueQuarantinePath(dir, key, ".json");
+    (0, import_node_fs2.writeFileSync)(candidate, input.raw ?? "", { flag: "wx", mode: 384 });
+    backupPath = candidate;
+  } catch {
+  }
+  try {
+    withStatement(
+      input.db,
+      `DELETE FROM ${APP_STORAGE_TABLE} WHERE namespace = ?`,
+      (statement) => statement.run(input.namespace)
+    );
+  } catch (error) {
+    if (backupPath) {
+      try {
+        (0, import_node_fs2.rmSync)(backupPath, { force: true });
+      } catch {
+      }
+    }
+    throw error;
+  }
+  return {
+    event: {
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      scope: "document",
+      dbPath: input.dbPath,
+      namespace: input.namespace,
+      backupPath,
+      reason: input.reason
+    },
+    quarantineKey: key
+  };
+}
+function discardStagedDocumentRecovery(recovery) {
+  if (!recovery?.event.backupPath) {
+    return;
+  }
+  try {
+    (0, import_node_fs2.rmSync)(recovery.event.backupPath, { force: true });
+  } catch {
+  }
+}
+async function finalizeDocumentRecovery(recovery) {
+  if (!recovery) {
+    return;
+  }
+  recordRecovery(recovery.event);
+  await pruneQuarantineCopies({
+    dir: quarantineDirFor(recovery.event.dbPath),
+    key: recovery.quarantineKey,
+    extension: ".json",
+    legacyPrefix: `${safeFileNamePart(recovery.event.namespace ?? "unknown")}-`
+  });
+}
+async function copyDatabaseToQuarantine(dbPath) {
+  const dir = quarantineDirFor(dbPath);
+  await import_node_fs3.promises.mkdir(dir, { recursive: true, mode: 448 });
+  if (process.platform !== "win32") {
+    await import_node_fs3.promises.chmod(dir, 448);
+  }
+  const key = quarantineKey("database", import_node_path2.default.basename(dbPath));
+  const target = uniqueQuarantinePath(dir, key, ".sqlite");
+  const copiedSuffixes = [];
+  try {
+    await import_node_fs3.promises.copyFile(dbPath, target);
+    copiedSuffixes.push("");
+    if (process.platform !== "win32") {
+      await import_node_fs3.promises.chmod(target, 384);
+    }
+    for (const suffix of ["-wal", "-shm"]) {
+      try {
+        await import_node_fs3.promises.copyFile(`${dbPath}${suffix}`, `${target}${suffix}`);
+        copiedSuffixes.push(suffix);
+        if (process.platform !== "win32") {
+          await import_node_fs3.promises.chmod(`${target}${suffix}`, 384);
+        }
+      } catch (error) {
+        if (error.code !== "ENOENT") {
+          throw error;
+        }
+      }
+    }
+  } catch (error) {
+    for (const copiedSuffix of copiedSuffixes) {
+      await import_node_fs3.promises.rm(`${target}${copiedSuffix}`, { force: true }).catch(() => void 0);
+    }
+    throw error;
+  }
+  return { backupPath: target, quarantineKey: key };
+}
+async function installReplacementDatabase(dbPath, replacementPath) {
+  for (const suffix of ["-wal", "-shm"]) {
+    await import_node_fs3.promises.rm(`${dbPath}${suffix}`, { force: true });
+  }
+  try {
+    await import_node_fs3.promises.rename(replacementPath, dbPath);
+  } catch (error) {
+    const code = error.code;
+    if (code !== "EEXIST" && code !== "EPERM") {
+      throw error;
+    }
+    await import_node_fs3.promises.copyFile(replacementPath, dbPath);
+    await import_node_fs3.promises.rm(replacementPath, { force: true }).catch(() => void 0);
   }
-  const message = typeof sqliteError.message === "string" ? sqliteError.message.toLowerCase() : "";
-  return sqliteError.code === "SQLITE_CORRUPT" || sqliteError.code === "SQLITE_NOTADB" || sqliteError.errno === 11 || sqliteError.errno === 26 || message.includes("database disk image is malformed") || message.includes("file is not a database") || message.includes("database corruption") || message.includes("sqlite_corrupt") || message.includes("sqlite_notadb");
 }
 function beginImmediate(db) {
   db.exec("BEGIN IMMEDIATE");
@@ -2311,7 +2586,7 @@ function rollback(db) {
   } catch {
   }
 }
-function useStatement(db, sql, task) {
+function withStatement(db, sql, task) {
   const statement = db.prepare(sql);
   try {
     return task(statement);
@@ -2341,10 +2616,11 @@ function applyConnectionPragmas(db) {
   db.exec("PRAGMA journal_mode = WAL;");
   db.exec("PRAGMA foreign_keys = ON;");
 }
-function ensureSchema(db, dbPath) {
-  if (initializedDbPaths.has(dbPath)) {
-    return;
-  }
+function applyReadConnectionPragmas(db) {
+  db.exec(`PRAGMA busy_timeout = ${SQLITE_BUSY_TIMEOUT_MS};`);
+  db.exec("PRAGMA foreign_keys = ON;");
+}
+function ensureSchema(db) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS ${APP_STORAGE_TABLE} (
       namespace TEXT PRIMARY KEY,
@@ -2352,76 +2628,387 @@ function ensureSchema(db, dbPath) {
       updated_at TEXT NOT NULL
     )
   `);
-  initializedDbPaths.add(dbPath);
 }
 async function openDatabase(dbPath) {
-  const dbDir = import_node_path.default.dirname(dbPath);
-  await import_node_fs.promises.mkdir(dbDir, { recursive: true, mode: 448 });
+  const dbDir = import_node_path2.default.dirname(dbPath);
+  await import_node_fs3.promises.mkdir(dbDir, { recursive: true, mode: 448 });
   if (process.platform !== "win32") {
-    await import_node_fs.promises.chmod(dbDir, 448);
+    await import_node_fs3.promises.chmod(dbDir, 448);
   }
   if (process.versions.bun !== void 0) {
     const sqlite2 = await Function("return import('bun:sqlite')")();
     const database2 = new sqlite2.Database(dbPath);
-    const result3 = {
+    try {
+      if (process.platform !== "win32") {
+        await import_node_fs3.promises.chmod(dbPath, 384);
+      }
+      return {
+        exec: database2.exec.bind(database2),
+        prepare: database2.prepare.bind(database2),
+        close: database2.close.bind(database2)
+      };
+    } catch (error) {
+      database2.close();
+      throw error;
+    }
+  }
+  const sqlite = await Function("return import('node:sqlite')")();
+  const database = new sqlite.DatabaseSync(dbPath);
+  try {
+    if (process.platform !== "win32") {
+      await import_node_fs3.promises.chmod(dbPath, 384);
+    }
+    return {
+      exec: database.exec.bind(database),
+      prepare: database.prepare.bind(database),
+      close: database.close.bind(database)
+    };
+  } catch (error) {
+    database.close();
+    throw error;
+  }
+}
+async function openReadOnlyDatabase(dbPath) {
+  if (process.versions.bun !== void 0) {
+    const sqlite2 = await Function("return import('bun:sqlite')")();
+    const database2 = new sqlite2.Database(dbPath, { readonly: true });
+    return {
       exec: database2.exec.bind(database2),
       prepare: database2.prepare.bind(database2),
       close: database2.close.bind(database2)
     };
-    if (process.platform !== "win32") {
-      await import_node_fs.promises.chmod(dbPath, 384);
-    }
-    return result3;
   }
   const sqlite = await Function("return import('node:sqlite')")();
-  const database = new sqlite.DatabaseSync(dbPath);
-  const result2 = {
+  const database = new sqlite.DatabaseSync(dbPath, { readOnly: true });
+  return {
     exec: database.exec.bind(database),
     prepare: database.prepare.bind(database),
     close: database.close.bind(database)
   };
-  if (process.platform !== "win32") {
-    await import_node_fs.promises.chmod(dbPath, 384);
+}
+function sqliteBusyError(message) {
+  return Object.assign(new Error(message), { code: "SQLITE_BUSY" });
+}
+function isMissingStorageTableError(error) {
+  return matchesErrorChain(error, (candidate) => {
+    const message = typeof candidate.message === "string" ? candidate.message.toLowerCase() : "";
+    return message.includes(`no such table: ${APP_STORAGE_TABLE}`);
+  });
+}
+async function acquireDatabaseFileLock(dbPath, mode) {
+  const acquire = mode === "read" ? acquireCrossProcessFileReadLock : acquireCrossProcessFileLock;
+  for (let attempt = 1; attempt <= SQLITE_BUSY_MAX_ATTEMPTS; attempt += 1) {
+    const release = await acquire(dbPath);
+    if (release) {
+      return release;
+    }
+    if (attempt < SQLITE_BUSY_MAX_ATTEMPTS) {
+      await sleep(SQLITE_BUSY_RETRY_DELAY_MS * attempt);
+    }
   }
-  return result2;
+  throw sqliteBusyError(`App storage ${mode} lock is busy.`);
 }
-function resetAppStorageInitialization(dbPath) {
-  initializedDbPaths.delete(dbPath);
+async function probeDatabaseHealth(dbPath) {
+  if (!(0, import_node_fs2.existsSync)(dbPath)) {
+    return "healthy";
+  }
+  let db = null;
+  try {
+    db = await openReadOnlyDatabase(dbPath);
+    applyReadConnectionPragmas(db);
+    const row = withStatement(
+      db,
+      "PRAGMA quick_check(1)",
+      (statement) => statement.get()
+    );
+    return isRecord(row) && Object.values(row).some((value3) => value3 === "ok") ? "healthy" : "corrupt";
+  } catch (error) {
+    if (isAppStorageCorruptionError(error)) {
+      return "corrupt";
+    }
+    throw error;
+  } finally {
+    db?.close();
+  }
+}
+async function readSalvageableDocuments(dbPath) {
+  let db = null;
+  try {
+    db = await openReadOnlyDatabase(dbPath);
+    applyReadConnectionPragmas(db);
+    const rows = withStatement(
+      db,
+      `
+        SELECT
+          namespace,
+          value_json AS valueJson,
+          updated_at AS updatedAt
+        FROM ${APP_STORAGE_TABLE}
+      `,
+      (statement) => statement.all()
+    );
+    return rows.flatMap((row) => {
+      if (!isRecord(row) || typeof row.namespace !== "string" || typeof row.valueJson !== "string" || typeof row.updatedAt !== "string") {
+        return [];
+      }
+      return [{
+        namespace: row.namespace,
+        valueJson: row.valueJson,
+        updatedAt: row.updatedAt
+      }];
+    });
+  } catch (error) {
+    if (isAppStorageCorruptionError(error) || isMissingStorageTableError(error)) {
+      return [];
+    }
+    throw error;
+  } finally {
+    db?.close();
+  }
+}
+async function buildReplacementDatabase(dbPath, rows) {
+  const replacementPath = `${dbPath}.recovery-${(0, import_node_crypto.randomUUID)()}.sqlite`;
+  try {
+    const db = await openDatabase(replacementPath);
+    try {
+      db.exec(`PRAGMA busy_timeout = ${SQLITE_BUSY_TIMEOUT_MS};`);
+      db.exec("PRAGMA journal_mode = DELETE;");
+      db.exec("PRAGMA foreign_keys = ON;");
+      ensureSchema(db);
+      beginImmediate(db);
+      try {
+        for (const row of rows) {
+          withStatement(
+            db,
+            `
+              INSERT INTO ${APP_STORAGE_TABLE} (namespace, value_json, updated_at)
+              VALUES (?, ?, ?)
+            `,
+            (statement) => statement.run(row.namespace, row.valueJson, row.updatedAt)
+          );
+        }
+        commit(db);
+      } catch (error) {
+        rollback(db);
+        throw error;
+      }
+    } finally {
+      db.close();
+    }
+    return replacementPath;
+  } catch (error) {
+    await import_node_fs3.promises.rm(replacementPath, { force: true });
+    throw error;
+  }
+}
+async function restoreQuarantinedDatabase(dbPath, backupPath) {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    if (!(0, import_node_fs2.existsSync)(`${backupPath}${suffix}`) || (0, import_node_fs2.existsSync)(`${dbPath}${suffix}`)) {
+      continue;
+    }
+    try {
+      await import_node_fs3.promises.rename(`${backupPath}${suffix}`, `${dbPath}${suffix}`);
+    } catch {
+    }
+  }
+}
+async function performDatabaseRecovery(dbPath, reason) {
+  const release = await acquireDatabaseFileLock(dbPath, "write");
+  try {
+    if (await probeDatabaseHealth(dbPath) === "healthy") {
+      return;
+    }
+    const salvagedRows = await readSalvageableDocuments(dbPath);
+    const replacementPath = await buildReplacementDatabase(dbPath, salvagedRows);
+    let backup = null;
+    try {
+      backup = await copyDatabaseToQuarantine(dbPath);
+      await installReplacementDatabase(dbPath, replacementPath);
+    } catch (error) {
+      await import_node_fs3.promises.rm(replacementPath, { force: true });
+      if (backup) {
+        await restoreQuarantinedDatabase(dbPath, backup.backupPath);
+      }
+      throw error;
+    }
+    recordRecovery({
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      scope: "database",
+      dbPath,
+      namespace: null,
+      backupPath: backup.backupPath,
+      reason: `${reason} Salvaged ${salvagedRows.length} document(s).`
+    });
+    await pruneQuarantineCopies({
+      dir: quarantineDirFor(dbPath),
+      key: backup.quarantineKey,
+      extension: ".sqlite",
+      databaseSidecars: true,
+      legacyPrefix: `${safeFileNamePart(import_node_path2.default.basename(dbPath))}-`
+    });
+  } finally {
+    await release();
+  }
+}
+async function recoverCorruptDatabase(dbPath, reason) {
+  const activeRecovery = databaseRecoveryByDbPath.get(dbPath);
+  if (activeRecovery) {
+    return activeRecovery;
+  }
+  const recovery = performDatabaseRecovery(dbPath, reason);
+  databaseRecoveryByDbPath.set(dbPath, recovery);
+  try {
+    await recovery;
+  } finally {
+    if (databaseRecoveryByDbPath.get(dbPath) === recovery) {
+      databaseRecoveryByDbPath.delete(dbPath);
+    }
+  }
 }
 async function withDatabase(dbPath, task) {
-  for (let attempt = 1; attempt <= SQLITE_BUSY_MAX_ATTEMPTS; attempt += 1) {
+  let busyAttempts = 0;
+  let databaseRecovered = false;
+  for (; ; ) {
     let db = null;
+    let releaseFileLock = null;
+    let corruption = null;
     try {
+      releaseFileLock = await acquireDatabaseFileLock(dbPath, "read");
       db = await openDatabase(dbPath);
       applyConnectionPragmas(db);
-      ensureSchema(db, dbPath);
+      ensureSchema(db);
       return task(db);
     } catch (error) {
-      if (error instanceof AppStorageCorruptionError) {
+      if (isAppStorageCorruptionError(error)) {
+        if (databaseRecovered) {
+          throw error instanceof AppStorageCorruptionError ? error : new AppStorageCorruptionError("App storage database is corrupt.", {
+            dbPath,
+            cause: error
+          });
+        }
+        databaseRecovered = true;
+        corruption = error;
+      } else if (!isSqliteBusyError2(error)) {
         throw error;
+      } else {
+        busyAttempts += 1;
+        if (busyAttempts >= SQLITE_BUSY_MAX_ATTEMPTS) {
+          throw error;
+        }
       }
-      if (isSqliteCorruptionError(error)) {
+    } finally {
+      db?.close();
+      await releaseFileLock?.();
+    }
+    if (corruption) {
+      try {
+        await recoverCorruptDatabase(dbPath, describeError(corruption));
+      } catch (error) {
+        if (isSqliteBusyError2(error) || isStorageUnavailableError(error)) {
+          throw error;
+        }
         throw new AppStorageCorruptionError(
-          "App storage database is corrupt.",
+          "App storage database is corrupt and could not be moved aside.",
           { dbPath, cause: error }
         );
       }
-      if (!isSqliteBusyError(error) || attempt >= SQLITE_BUSY_MAX_ATTEMPTS) {
+      continue;
+    }
+    await sleep(SQLITE_BUSY_RETRY_DELAY_MS * busyAttempts);
+  }
+}
+async function withReadOnlyDatabase(dbPath, task) {
+  let busyAttempts = 0;
+  let databaseRecovered = false;
+  for (; ; ) {
+    let db = null;
+    let releaseFileLock = null;
+    let corruption = null;
+    let requiresReadWriteFallback = false;
+    try {
+      try {
+        releaseFileLock = await acquireDatabaseFileLock(dbPath, "read");
+      } catch (error) {
+        if (!isStorageUnavailableError(error)) {
+          throw error;
+        }
+      }
+      db = await openReadOnlyDatabase(dbPath);
+      applyReadConnectionPragmas(db);
+      return task(db);
+    } catch (error) {
+      if (isMissingStorageTableError(error) || isSqliteCantOpenError(error)) {
+        requiresReadWriteFallback = true;
+      } else if (isAppStorageCorruptionError(error)) {
+        if (databaseRecovered) {
+          throw error;
+        }
+        databaseRecovered = true;
+        corruption = error;
+      } else if (!isSqliteBusyError2(error)) {
         throw error;
+      } else {
+        busyAttempts += 1;
+        if (busyAttempts >= SQLITE_BUSY_MAX_ATTEMPTS) {
+          throw error;
+        }
       }
     } finally {
       db?.close();
+      await releaseFileLock?.();
+    }
+    if (requiresReadWriteFallback) {
+      return withDatabase(dbPath, task);
+    }
+    if (corruption) {
+      await recoverCorruptDatabase(dbPath, describeError(corruption));
+      continue;
     }
-    await sleep(SQLITE_BUSY_RETRY_DELAY_MS * attempt);
+    await sleep(SQLITE_BUSY_RETRY_DELAY_MS * busyAttempts);
   }
-  throw new Error("App storage database remained busy after retrying.");
+}
+async function withReadableDatabase(dbPath, task) {
+  return (0, import_node_fs2.existsSync)(dbPath) ? withReadOnlyDatabase(dbPath, task) : withDatabase(dbPath, task);
 }
 function resolveAppStorageDbPath(userDataDir) {
-  return import_node_path.default.join(userDataDir, APP_STORAGE_DB_DIR, APP_STORAGE_DB_NAME);
+  return import_node_path2.default.join(userDataDir, APP_STORAGE_DB_DIR, APP_STORAGE_DB_NAME);
+}
+function readStrictDocumentRow(input) {
+  const row = withStatement(
+    input.db,
+    `SELECT value_json AS valueJson FROM ${APP_STORAGE_TABLE} WHERE namespace = ?`,
+    (statement) => statement.get(input.namespace)
+  );
+  if (!isRecord(row)) {
+    return { kind: "absent" };
+  }
+  const raw = typeof row.valueJson === "string" ? row.valueJson : null;
+  if (raw === null || raw.trim().length === 0) {
+    return { kind: "damaged", raw, reason: "Stored document is empty." };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    return {
+      kind: "damaged",
+      raw,
+      reason: `Stored document is not valid JSON: ${describeError(error)}`
+    };
+  }
+  try {
+    return { kind: "value", value: input.normalize(parsed) };
+  } catch (error) {
+    return {
+      kind: "damaged",
+      raw,
+      reason: `Stored document failed validation: ${describeError(error)}`
+    };
+  }
 }
 async function readDocument(dbPath, namespace, normalize3) {
-  return withDatabase(dbPath, (db) => {
-    const row = useStatement(
+  return withReadableDatabase(dbPath, (db) => {
+    const row = withStatement(
       db,
       `SELECT value_json AS valueJson FROM ${APP_STORAGE_TABLE} WHERE namespace = ?`,
       (statement) => statement.get(namespace)
@@ -2434,38 +3021,46 @@ async function readDocument(dbPath, namespace, normalize3) {
   });
 }
 async function readDocumentStrict(dbPath, namespace, normalize3) {
-  return withDatabase(dbPath, (db) => {
-    const row = useStatement(
-      db,
-      `SELECT value_json AS valueJson FROM ${APP_STORAGE_TABLE} WHERE namespace = ?`,
-      (statement) => statement.get(namespace)
-    );
-    if (!isRecord(row)) {
-      return null;
-    }
-    const parsed = parseJsonStrict(row.valueJson, {
-      dbPath,
-      namespace
-    });
-    if (parsed === null) {
-      throw new AppStorageCorruptionError(
-        `App storage document ${namespace} is empty.`,
-        { dbPath, namespace }
-      );
-    }
-    try {
-      return normalize3(parsed);
-    } catch (error) {
-      throw new AppStorageCorruptionError(
-        `App storage document ${namespace} failed normalization.`,
-        {
-          dbPath,
-          namespace,
-          cause: error
+  const initialRead = await withReadableDatabase(
+    dbPath,
+    (db) => readStrictDocumentRow({ db, namespace, normalize: normalize3 })
+  );
+  if (initialRead.kind === "value") {
+    return initialRead.value;
+  }
+  if (initialRead.kind === "absent") {
+    return null;
+  }
+  const recovered = await withWriteQueue(
+    dbPath,
+    async () => withDatabase(dbPath, (db) => {
+      let stagedRecovery = null;
+      beginImmediate(db);
+      try {
+        const read = readStrictDocumentRow({ db, namespace, normalize: normalize3 });
+        let value3 = null;
+        if (read.kind === "value") {
+          value3 = read.value;
+        } else if (read.kind === "damaged") {
+          stagedRecovery = stageDamagedDocumentRecovery({
+            db,
+            dbPath,
+            namespace,
+            raw: read.raw,
+            reason: read.reason
+          });
         }
-      );
-    }
-  });
+        commit(db);
+        return { value: value3, stagedRecovery };
+      } catch (error) {
+        rollback(db);
+        discardStagedDocumentRecovery(stagedRecovery);
+        throw error;
+      }
+    })
+  );
+  await finalizeDocumentRecovery(recovered.stagedRecovery);
+  return recovered.value;
 }
 async function writeDocument(dbPath, namespace, value3, options = {}) {
   return withWriteQueue(
@@ -2474,7 +3069,7 @@ async function writeDocument(dbPath, namespace, value3, options = {}) {
       const normalizedValue = options.cloneValue === false ? value3 : clone(value3);
       beginImmediate(db);
       try {
-        useStatement(
+        withStatement(
           db,
           `
               INSERT INTO ${APP_STORAGE_TABLE} (namespace, value_json, updated_at)
@@ -2496,36 +3091,42 @@ async function writeDocument(dbPath, namespace, value3, options = {}) {
   );
 }
 async function updateDocument(input) {
-  return withWriteQueue(
+  const updated = await withWriteQueue(
     input.dbPath,
     async () => withDatabase(input.dbPath, (db) => {
+      let stagedRecovery = null;
       beginImmediate(db);
       try {
-        const row = useStatement(
-          db,
-          `SELECT value_json AS valueJson FROM ${APP_STORAGE_TABLE} WHERE namespace = ?`,
-          (statement) => statement.get(input.namespace)
-        );
         let current;
-        if (isRecord(row)) {
-          const parsed = input.strictExisting ? parseJsonStrict(row.valueJson, {
-            dbPath: input.dbPath,
-            namespace: input.namespace
-          }) : safeParseJson(row.valueJson);
-          if (parsed === null && input.strictExisting) {
-            throw new AppStorageCorruptionError(
-              `App storage document ${input.namespace} is empty.`,
-              { dbPath: input.dbPath, namespace: input.namespace }
-            );
+        if (input.strictExisting) {
+          const read = readStrictDocumentRow({
+            db,
+            namespace: input.namespace,
+            normalize: input.normalize
+          });
+          if (read.kind === "damaged") {
+            stagedRecovery = stageDamagedDocumentRecovery({
+              db,
+              dbPath: input.dbPath,
+              namespace: input.namespace,
+              raw: read.raw,
+              reason: read.reason
+            });
           }
-          current = input.normalize(parsed ?? input.fallback());
+          current = read.kind === "value" ? read.value : input.fallback();
         } else {
-          current = input.fallback();
+          const row = withStatement(
+            db,
+            `SELECT value_json AS valueJson FROM ${APP_STORAGE_TABLE} WHERE namespace = ?`,
+            (statement) => statement.get(input.namespace)
+          );
+          const parsed = isRecord(row) ? safeParseJson(row.valueJson) : null;
+          current = input.normalize(parsed ?? input.fallback());
         }
         const transformInput = input.cloneBeforeTransform === false ? current : clone(current);
         const transformed = input.transform(transformInput);
         const next = input.normalizeResult === false ? transformed : input.normalize(transformed);
-        useStatement(
+        withStatement(
           db,
           `
               INSERT INTO ${APP_STORAGE_TABLE} (namespace, value_json, updated_at)
@@ -2538,13 +3139,19 @@ async function updateDocument(input) {
           (statement) => statement.run(input.namespace, JSON.stringify(next), (/* @__PURE__ */ new Date()).toISOString())
         );
         commit(db);
-        return input.cloneResult === false ? next : clone(next);
+        return {
+          value: input.cloneResult === false ? next : clone(next),
+          stagedRecovery
+        };
       } catch (error) {
         rollback(db);
+        discardStagedDocumentRecovery(stagedRecovery);
         throw error;
       }
     })
   );
+  await finalizeDocumentRecovery(updated.stagedRecovery);
+  return updated.value;
 }
 async function deleteDocument(dbPath, namespace) {
   await withWriteQueue(
@@ -2552,7 +3159,7 @@ async function deleteDocument(dbPath, namespace) {
     async () => withDatabase(dbPath, (db) => {
       beginImmediate(db);
       try {
-        useStatement(
+        withStatement(
           db,
           `DELETE FROM ${APP_STORAGE_TABLE} WHERE namespace = ?`,
           (statement) => statement.run(namespace)
@@ -2569,8 +3176,15 @@ async function deleteDocument(dbPath, namespace) {
 // ../../packages/runtime-app-state/src/app/state.ts
 var APP_STATE_DOCUMENT = "desktop.app-state";
 var APP_NAME = "codexuse-desktop";
+var PERSISTENCE_RETRY_COOLDOWN_MS = 5e3;
+var PERSISTENCE_READ_DEADLINE_MS = 8e3;
+var READ_TOO_SLOW = /* @__PURE__ */ Symbol("app-state-read-too-slow");
 var configuredUserDataDir = null;
 var appStateCache = null;
+var ephemeralAppState = null;
+var persistenceFailure = null;
+var pendingRendererUiPatch = null;
+var nextPersistenceRetryAt = 0;
 var writeLock = Promise.resolve();
 var writeLockContext = new import_node_async_hooks.AsyncLocalStorage();
 function isRecord2(value3) {
@@ -2601,7 +3215,7 @@ function resolveDefaultUserDataDir() {
   if (!home) {
     throw new Error("Unable to resolve home directory for app state.");
   }
-  return import_node_path2.default.join(home, "Library", "Application Support", APP_NAME);
+  return import_node_path3.default.join(home, "Library", "Application Support", APP_NAME);
 }
 function getUserDataDir() {
   return configuredUserDataDir ?? resolveDefaultUserDataDir();
@@ -2638,7 +3252,7 @@ function createDefaultAppState() {
       desktopLlmEnabled: false,
       desktopLlmRegistry: {
         version: 3,
-        revision: (0, import_node_crypto.createHash)("sha256").update("empty").digest("hex"),
+        revision: (0, import_node_crypto2.createHash)("sha256").update("empty").digest("hex"),
         providers: [],
         routes: [],
         externalProfiles: []
@@ -2933,7 +3547,7 @@ function normalizeOfficialCodexRelayProfile(value3) {
 }
 function migrateDesktopLlmRegistry(profiles) {
   const entries3 = Object.values(profiles).filter((profile) => Boolean(profile.model)).sort((left, right) => left.id.localeCompare(right.id));
-  const revision = (0, import_node_crypto.createHash)("sha256").update(
+  const revision = (0, import_node_crypto2.createHash)("sha256").update(
     JSON.stringify(
       entries3.map((profile) => [
         profile.id,
@@ -3257,7 +3871,7 @@ function normalizeDesktopLlmRegistry(value3, profiles) {
       externalProfiles.sort((left, right) => left.updatedAt.localeCompare(right.updatedAt)).map((profile) => [profile.id, profile])
     ).values()
   ).sort((left, right) => left.id.localeCompare(right.id));
-  const revision = (0, import_node_crypto.createHash)("sha256").update(
+  const revision = (0, import_node_crypto2.createHash)("sha256").update(
     JSON.stringify({
       providers: providers.map((provider) => ({
         id: provider.id,
@@ -3898,10 +4512,10 @@ function normalizeAppState(raw) {
         ([rootPath, profileName]) => {
           const normalizedRoot = asString(rootPath);
           const normalizedProfile = asString(profileName);
-          if (!normalizedRoot || !import_node_path2.default.isAbsolute(normalizedRoot) || !normalizedProfile) {
+          if (!normalizedRoot || !import_node_path3.default.isAbsolute(normalizedRoot) || !normalizedProfile) {
             return [];
           }
-          return [[import_node_path2.default.normalize(normalizedRoot), normalizedProfile]];
+          return [[import_node_path3.default.normalize(normalizedRoot), normalizedProfile]];
         }
       )
     );
@@ -3942,22 +4556,85 @@ async function readAppStateFromStorage() {
     normalizeAppState
   );
 }
-async function ensureInitialized() {
-  if (appStateCache) {
-    return appStateCache;
+async function readStoredAppStateOrNull() {
+  try {
+    return await readStoredAppStateForInit();
+  } catch (error) {
+    persistenceFailure = {
+      kind: classifyAppStorageFailure(error),
+      message: error instanceof Error ? error.message : String(error)
+    };
+    nextPersistenceRetryAt = Date.now() + PERSISTENCE_RETRY_COOLDOWN_MS;
+    return null;
   }
-  const stored = await updateDocument({
+}
+async function readStoredAppStateForInit() {
+  const stored = await readAppStateFromStorage();
+  if (stored && !pendingRendererUiPatch) {
+    return stored;
+  }
+  const pendingUiPatch = pendingRendererUiPatch;
+  const initialized = await updateDocument({
     dbPath: resolveStorageDbPath(),
     namespace: APP_STATE_DOCUMENT,
     normalize: normalizeAppState,
     fallback: () => normalizeAppState(null),
-    transform: (current) => current,
+    transform: (current) => pendingUiPatch ? deepMerge(current, { ui: pendingUiPatch }) : current,
     cloneBeforeTransform: false,
     cloneResult: false,
     strictExisting: true
   });
-  appStateCache = freezeDeep(stored);
-  return appStateCache;
+  if (pendingRendererUiPatch === pendingUiPatch) {
+    pendingRendererUiPatch = null;
+  }
+  return initialized;
+}
+function degradeToMemory(kind, message) {
+  persistenceFailure = { kind, message };
+  nextPersistenceRetryAt = Date.now() + PERSISTENCE_RETRY_COOLDOWN_MS;
+  if (appStateCache) {
+    return appStateCache;
+  }
+  ephemeralAppState = ephemeralAppState ?? freezeDeep(normalizeAppState(null));
+  return ephemeralAppState;
+}
+async function ensureInitialized() {
+  if (appStateCache && !persistenceFailure) {
+    return appStateCache;
+  }
+  const memoryState = appStateCache ?? ephemeralAppState;
+  if (memoryState && Date.now() < nextPersistenceRetryAt) {
+    return memoryState;
+  }
+  const attempt = readStoredAppStateForInit();
+  attempt.catch(() => void 0);
+  let deadlineTimer;
+  const deadline = new Promise((resolve2) => {
+    deadlineTimer = setTimeout(
+      () => resolve2(READ_TOO_SLOW),
+      PERSISTENCE_READ_DEADLINE_MS
+    );
+  });
+  try {
+    const outcome = await Promise.race([attempt, deadline]);
+    if (outcome === READ_TOO_SLOW) {
+      return degradeToMemory(
+        "busy",
+        `Saved app state did not load within ${PERSISTENCE_READ_DEADLINE_MS}ms.`
+      );
+    }
+    appStateCache = freezeDeep(outcome);
+    ephemeralAppState = null;
+    persistenceFailure = null;
+    return appStateCache;
+  } catch (error) {
+    return degradeToMemory(
+      classifyAppStorageFailure(error),
+      error instanceof Error ? error.message : String(error)
+    );
+  } finally {
+    clearTimeout(deadlineTimer);
+  }
 }
 async function withWriteLock(task) {
   if (writeLockContext.getStore()) {
@@ -3981,7 +4658,10 @@ async function initializeAppState(userDataDir) {
   if (configuredUserDataDir !== userDataDir) {
     configuredUserDataDir = userDataDir;
     appStateCache = null;
-    resetAppStorageInitialization(resolveStorageDbPath());
+    ephemeralAppState = null;
+    persistenceFailure = null;
+    pendingRendererUiPatch = null;
+    nextPersistenceRetryAt = 0;
   }
   const state = await ensureInitialized();
   return state;
@@ -3992,8 +4672,13 @@ async function getAppState() {
 }
 async function refreshAppStateCache() {
   return withWriteLock(async () => {
-    const current = await readAppStateFromStorage() ?? await ensureInitialized();
-    appStateCache = freezeDeep(current);
+    const stored = await readStoredAppStateOrNull();
+    if (!stored) {
+      return ensureInitialized();
+    }
+    appStateCache = freezeDeep(stored);
+    ephemeralAppState = null;
+    persistenceFailure = null;
     return appStateCache;
   });
 }
@@ -4001,24 +4686,40 @@ async function updateAppState(transform3, options = {}) {
   const mode = options.mode ?? "patch";
   return withWriteLock(async () => {
     const shouldNormalize = options.normalize !== false;
-    const stored = await updateDocument({
-      dbPath: resolveStorageDbPath(),
-      namespace: APP_STATE_DOCUMENT,
-      normalize: normalizeAppState,
-      fallback: () => normalizeAppState(null),
-      cloneBeforeTransform: false,
-      normalizeResult: shouldNormalize,
-      cloneResult: false,
-      strictExisting: true,
-      transform: (current) => {
-        const transformed = transform3(
-          options.cloneCurrent === false ? current : clone2(current)
-        );
-        return mode === "replace" ? transformed : deepMerge(current, transformed);
+    const pendingUiPatch = pendingRendererUiPatch;
+    try {
+      const stored = await updateDocument({
+        dbPath: resolveStorageDbPath(),
+        namespace: APP_STATE_DOCUMENT,
+        normalize: normalizeAppState,
+        fallback: () => normalizeAppState(null),
+        cloneBeforeTransform: false,
+        normalizeResult: shouldNormalize,
+        cloneResult: false,
+        strictExisting: true,
+        transform: (current) => {
+          const transformed = transform3(
+            options.cloneCurrent === false ? current : clone2(current)
+          );
+          const next = mode === "replace" ? transformed : deepMerge(current, transformed);
+          return pendingUiPatch ? deepMerge(next, { ui: pendingUiPatch }) : next;
+        }
+      });
+      if (pendingRendererUiPatch === pendingUiPatch) {
+        pendingRendererUiPatch = null;
       }
-    });
-    appStateCache = freezeDeep(stored);
-    return appStateCache;
+      appStateCache = freezeDeep(stored);
+      ephemeralAppState = null;
+      persistenceFailure = null;
+      return appStateCache;
+    } catch (error) {
+      persistenceFailure = {
+        kind: classifyAppStorageFailure(error),
+        message: error instanceof Error ? error.message : String(error)
+      };
+      nextPersistenceRetryAt = Date.now() + PERSISTENCE_RETRY_COOLDOWN_MS;
+      throw error;
+    }
   });
 }
 async function patchAppState(patch) {
@@ -4131,7 +4832,7 @@ async function updateAppSettings(transform3, onUpdated) {
 }
 
 // ../../packages/runtime-profiles/src/license/service.ts
-var import_node_crypto6 = __toESM(require("crypto"), 1);
+var import_node_crypto7 = __toESM(require("crypto"), 1);
 
 // ../../packages/runtime-codex/src/codex/settings.ts
 function asString2(value3) {
@@ -4370,10 +5071,10 @@ async function writeCodexSettingsJsonRaw(payload) {
 }
 
 // ../../packages/runtime-profiles/src/license/secret.ts
-var import_node_crypto2 = __toESM(require("crypto"), 1);
+var import_node_crypto3 = __toESM(require("crypto"), 1);
 var LICENSE_SECRET_DOCUMENT = "desktop.license-secret";
 async function generateSecret() {
-  return import_node_crypto2.default.randomBytes(32).toString("hex");
+  return import_node_crypto3.default.randomBytes(32).toString("hex");
 }
 function normalizeSecret(value3) {
   return typeof value3 === "string" ? value3.trim() : "";
@@ -4434,10 +5135,10 @@ function buildCheckoutUrl(offer2, options) {
 }
 
 // ../../packages/runtime-profiles/src/license/trial.ts
-var import_node_crypto5 = __toESM(require("crypto"), 1);
+var import_node_crypto6 = __toESM(require("crypto"), 1);
 
 // ../../packages/runtime-profiles/src/license/device-id.ts
-var import_node_crypto3 = __toESM(require("crypto"), 1);
+var import_node_crypto4 = __toESM(require("crypto"), 1);
 var import_promises = require("fs/promises");
 var import_node_child_process = require("child_process");
 var import_node_util = require("util");
@@ -4480,7 +5181,7 @@ async function readLinuxMachineId() {
   return null;
 }
 function hashDeviceComponent(value3) {
-  return import_node_crypto3.default.createHash("sha256").update(`codexuse-device:${value3}`).digest("hex");
+  return import_node_crypto4.default.createHash("sha256").update(`codexuse-device:${value3}`).digest("hex");
 }
 async function getDeviceId() {
   if (memoizedDeviceId) {
@@ -4501,7 +5202,7 @@ async function getDeviceId() {
     memoizedDeviceId = cached2;
     return cached2;
   }
-  const seed = import_node_crypto3.default.randomBytes(32).toString("hex");
+  const seed = import_node_crypto4.default.randomBytes(32).toString("hex");
   const deviceId = hashDeviceComponent(seed);
   await writeDocument(dbPath, DEVICE_ID_DOCUMENT, deviceId);
   memoizedDeviceId = deviceId;
@@ -4512,7 +5213,7 @@ function hashEmail(email) {
   if (!normalized) {
     return null;
   }
-  return import_node_crypto3.default.createHash("sha256").update(`codexuse-email:${normalized}`).digest("hex");
+  return import_node_crypto4.default.createHash("sha256").update(`codexuse-email:${normalized}`).digest("hex");
 }
 
 // ../../packages/runtime-profiles/src/license/trial-client.ts
@@ -4567,17 +5268,17 @@ async function registerTrialWithServer(input) {
 }
 
 // ../../packages/runtime-profiles/src/license/trial-token-store.ts
-var import_node_crypto4 = require("crypto");
+var import_node_crypto5 = require("crypto");
 var import_node_child_process2 = require("child_process");
 var KEYCHAIN_SERVICE = "CODEXUSE_TRIAL_TOKEN";
 var KEYCHAIN_ACCOUNT_PREFIX = "device-sha256:";
 var FALLBACK_DOCUMENT_PREFIX = "desktop.trial-token.";
 function keychainAccountForDevice(deviceId) {
-  const digest = (0, import_node_crypto4.createHash)("sha256").update(deviceId).digest("hex");
+  const digest = (0, import_node_crypto5.createHash)("sha256").update(deviceId).digest("hex");
   return KEYCHAIN_ACCOUNT_PREFIX + digest;
 }
 function fallbackDocumentForDevice(deviceId) {
-  const digest = (0, import_node_crypto4.createHash)("sha256").update(deviceId).digest("hex");
+  const digest = (0, import_node_crypto5.createHash)("sha256").update(deviceId).digest("hex");
   return FALLBACK_DOCUMENT_PREFIX + digest;
 }
 function normalizeToken(value3) {
@@ -4681,7 +5382,7 @@ function trialSignaturePayload(trial) {
   });
 }
 function signTrial(trial, secret) {
-  return import_node_crypto5.default.createHmac("sha256", secret).update(trialSignaturePayload(trial)).digest("hex");
+  return import_node_crypto6.default.createHmac("sha256", secret).update(trialSignaturePayload(trial)).digest("hex");
 }
 function withTrialSignature(trial, secret) {
   return { ...trial, signature: signTrial(trial, secret) };
@@ -4995,7 +5696,7 @@ function licenseSignaturePayload(license) {
   return JSON.stringify(payload);
 }
 function signLicense(license, secret) {
-  return import_node_crypto6.default.createHmac("sha256", secret).update(licenseSignaturePayload(license)).digest("hex");
+  return import_node_crypto7.default.createHmac("sha256", secret).update(licenseSignaturePayload(license)).digest("hex");
 }
 function withSignature(license, secret) {
   return {
@@ -5175,7 +5876,19 @@ var LicenseService = class {
     this.verificationPromise = null;
   }
   async getCachedStatus() {
-    return this.getStatus({ allowStale: true, refreshInBackground: true });
+    try {
+      return await this.getStatus({ allowStale: true, refreshInBackground: true });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "License status could not be loaded.";
+      console.warn("Cached license status unavailable:", error);
+      return toLicenseStatus(null, {
+        state: "error",
+        profileLimit: null,
+        profilesRemaining: null,
+        message: "License status is temporarily unavailable.",
+        error: message
+      });
+    }
   }
   async getStatus(options = {}) {
     const forceRefresh = Boolean(options.forceRefresh);
@@ -5291,7 +6004,7 @@ var LicenseService = class {
       throw new Error("License key is required.");
     }
     const secret = await getLicenseSecret();
-    const digest = import_node_crypto6.default.createHash("sha256").update(trimmed).digest("hex");
+    const digest = import_node_crypto7.default.createHash("sha256").update(trimmed).digest("hex");
     const result2 = await requestGumroadVerify(trimmed, "activation");
     ensureWithinUseLimit(result2);
     const normalized = normalizeVerificationResult(result2, "activation");
@@ -5354,7 +6067,7 @@ function shouldEnforceProfileLimit(status) {
 }
 
 // ../../packages/runtime-profiles/src/profiles/profile-manager.ts
-var import_node_crypto11 = require("crypto");
+var import_node_crypto12 = require("crypto");
 var import_fs = require("fs");
 var import_node_os5 = __toESM(require("os"), 1);
 var import_path = __toESM(require("path"), 1);
@@ -5413,29 +6126,29 @@ function resolveProfileIdentityKeyFromProfile(profile) {
 
 // ../../packages/runtime-codex/src/codex/rpc.ts
 var import_node_child_process5 = require("child_process");
-var import_node_crypto8 = require("crypto");
+var import_node_crypto9 = require("crypto");
 var import_node_readline = __toESM(require("readline"), 1);
-var import_node_fs5 = require("fs");
+var import_node_fs6 = require("fs");
 var import_node_os3 = __toESM(require("os"), 1);
 var import_node_path9 = __toESM(require("path"), 1);
 
 // ../../packages/runtime-codex/src/codex/cli.ts
-var import_node_fs2 = require("fs");
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_fs4 = require("fs");
+var import_node_path4 = __toESM(require("path"), 1);
 var STABLE_CHANNEL = "stable";
 var ENV_HINTS = ["CODEX_BINARY", "CODEX_CLI_PATH", "CODEX_PATH"];
 var cachedStatus = null;
 function getPathHintEntries() {
   const homeDir = process.env.HOME ?? "";
   const homeEntries = homeDir ? [
-    import_node_path3.default.join(homeDir, ".local", "bin"),
-    import_node_path3.default.join(homeDir, ".fnm", "aliases", "default", "bin"),
-    import_node_path3.default.join(homeDir, ".fnm", "current", "bin"),
-    import_node_path3.default.join(homeDir, ".volta", "bin"),
-    import_node_path3.default.join(homeDir, ".asdf", "shims"),
-    import_node_path3.default.join(homeDir, ".bun", "bin")
+    import_node_path4.default.join(homeDir, ".local", "bin"),
+    import_node_path4.default.join(homeDir, ".fnm", "aliases", "default", "bin"),
+    import_node_path4.default.join(homeDir, ".fnm", "current", "bin"),
+    import_node_path4.default.join(homeDir, ".volta", "bin"),
+    import_node_path4.default.join(homeDir, ".asdf", "shims"),
+    import_node_path4.default.join(homeDir, ".bun", "bin")
   ] : [];
-  const configuredHints = (process.env.CODEX_PATH_HINTS ?? "").split(import_node_path3.default.delimiter).map((entry) => entry.trim()).filter(Boolean);
+  const configuredHints = (process.env.CODEX_PATH_HINTS ?? "").split(import_node_path4.default.delimiter).map((entry) => entry.trim()).filter(Boolean);
   return [
     "/opt/homebrew/bin",
     "/usr/local/bin",
@@ -5447,9 +6160,9 @@ function fileExists(candidate) {
   if (!candidate) {
     return null;
   }
-  const normalized = import_node_path3.default.resolve(candidate);
+  const normalized = import_node_path4.default.resolve(candidate);
   try {
-    const stats = (0, import_node_fs2.statSync)(normalized);
+    const stats = (0, import_node_fs4.statSync)(normalized);
     if (stats.isFile()) {
       return normalized;
     }
@@ -5476,12 +6189,12 @@ function resolveCodexFromPath() {
     new Set(
       [
         ...getPathHintEntries(),
-        ...pathValue.split(import_node_path3.default.delimiter).map((entry) => entry.trim()).filter(Boolean)
+        ...pathValue.split(import_node_path4.default.delimiter).map((entry) => entry.trim()).filter(Boolean)
       ].filter(Boolean)
     )
   );
   for (const entry of entries3) {
-    const candidate = fileExists(import_node_path3.default.join(entry, "codex"));
+    const candidate = fileExists(import_node_path4.default.join(entry, "codex"));
     if (candidate) {
       return candidate;
     }
@@ -5545,7 +6258,7 @@ async function requireCodexCli() {
 
 // ../../packages/runtime-codex/src/codex/command.ts
 var import_node_child_process3 = require("child_process");
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 var cachedNodeRuntime = null;
 function isJavaScriptEntrypoint(binaryPath) {
   const normalized = binaryPath.trim().toLowerCase();
@@ -5561,19 +6274,19 @@ function resolveNodeRuntime(env) {
   }
   const runtimeEnv = { ...process.env, ...env };
   const homeDir = runtimeEnv.HOME ?? "";
-  const pathHints = (runtimeEnv.CODEX_PATH_HINTS ?? process.env.CODEX_PATH_HINTS ?? "").split(import_node_path4.default.delimiter).map((entry) => entry.trim()).filter(Boolean);
+  const pathHints = (runtimeEnv.CODEX_PATH_HINTS ?? process.env.CODEX_PATH_HINTS ?? "").split(import_node_path5.default.delimiter).map((entry) => entry.trim()).filter(Boolean);
   const extraPathEntries = [
     "/usr/local/bin",
     "/opt/homebrew/bin",
-    import_node_path4.default.join(homeDir, ".local", "bin"),
-    import_node_path4.default.join(homeDir, ".fnm", "aliases", "default", "bin"),
-    import_node_path4.default.join(homeDir, ".fnm", "current", "bin"),
+    import_node_path5.default.join(homeDir, ".local", "bin"),
+    import_node_path5.default.join(homeDir, ".fnm", "aliases", "default", "bin"),
+    import_node_path5.default.join(homeDir, ".fnm", "current", "bin"),
     ...pathHints
   ].filter(Boolean);
   const currentPath = runtimeEnv.PATH ?? "";
   runtimeEnv.PATH = Array.from(
-    /* @__PURE__ */ new Set([...extraPathEntries, ...currentPath.split(import_node_path4.default.delimiter).filter(Boolean)])
-  ).join(import_node_path4.default.delimiter);
+    /* @__PURE__ */ new Set([...extraPathEntries, ...currentPath.split(import_node_path5.default.delimiter).filter(Boolean)])
+  ).join(import_node_path5.default.delimiter);
   const candidates = Array.from(
     new Set(
       [
@@ -5612,11 +6325,11 @@ function buildCodexCommand(binaryPath, args2, env) {
 }
 
 // ../../packages/runtime-codex/src/codex/home.ts
-var import_node_crypto7 = require("crypto");
-var import_node_fs3 = require("fs");
+var import_node_crypto8 = require("crypto");
+var import_node_fs5 = require("fs");
 var import_promises2 = require("fs/promises");
 var import_node_os2 = __toESM(require("os"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
 function resolveHomeDir() {
   return process.env.HOME || import_node_os2.default.homedir();
 }
@@ -5625,7 +6338,7 @@ function expandHomePrefix(input, homeDir) {
     return homeDir;
   }
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return import_node_path5.default.join(homeDir, input.slice(2));
+    return import_node_path6.default.join(homeDir, input.slice(2));
   }
   return input;
 }
@@ -5641,25 +6354,25 @@ function normalizeCodexHomePath(input) {
   if (!configured) {
     return null;
   }
-  return import_node_path5.default.resolve(expandHomePrefix(configured, resolveHomeDir()));
+  return import_node_path6.default.resolve(expandHomePrefix(configured, resolveHomeDir()));
 }
 function resolveDefaultCodexHomeDir() {
-  return normalizeCodexHomePath(process.env.CODEX_HOME) ?? import_node_path5.default.join(resolveHomeDir(), ".codex");
+  return normalizeCodexHomePath(process.env.CODEX_HOME) ?? import_node_path6.default.join(resolveHomeDir(), ".codex");
 }
 function resolveCodexSqliteHomeDir(codexHomePath) {
   return normalizeCodexHomePath(process.env.CODEX_SQLITE_HOME) ?? resolveCodexHomeDir({ codexHomePath });
 }
 function resolveCurrentProfileCodexHomeDir(profileHomeId) {
-  return import_node_path5.default.join(
+  return import_node_path6.default.join(
     resolveProfileCodexHomesRoot(),
-    (0, import_node_crypto7.createHash)("sha256").update(profileHomeId).digest("hex").slice(0, 20)
+    (0, import_node_crypto8.createHash)("sha256").update(profileHomeId).digest("hex").slice(0, 20)
   );
 }
 function resolveProfileCodexHomeDir(profileHomeId) {
   const current = resolveCurrentProfileCodexHomeDir(profileHomeId);
-  const legacy = import_node_path5.default.join(resolveLegacyProfileCodexHomesRoot(), profileHomeId);
-  const currentExists = (0, import_node_fs3.existsSync)(current);
-  const legacyExists = (0, import_node_fs3.existsSync)(legacy);
+  const legacy = import_node_path6.default.join(resolveLegacyProfileCodexHomesRoot(), profileHomeId);
+  const currentExists = (0, import_node_fs5.existsSync)(current);
+  const legacyExists = (0, import_node_fs5.existsSync)(legacy);
   if (currentExists && legacyExists) {
     return current;
   }
@@ -5667,15 +6380,15 @@ function resolveProfileCodexHomeDir(profileHomeId) {
 }
 function findProfileCodexHomeLocationConflict(profileHomeId) {
   const current = resolveCurrentProfileCodexHomeDir(profileHomeId);
-  const legacy = import_node_path5.default.join(resolveLegacyProfileCodexHomesRoot(), profileHomeId);
-  return (0, import_node_fs3.existsSync)(current) && (0, import_node_fs3.existsSync)(legacy) ? { current, legacy } : null;
+  const legacy = import_node_path6.default.join(resolveLegacyProfileCodexHomesRoot(), profileHomeId);
+  return (0, import_node_fs5.existsSync)(current) && (0, import_node_fs5.existsSync)(legacy) ? { current, legacy } : null;
 }
 function resolveProfileCodexHomesRoot() {
-  return import_node_path5.default.join(resolveHomeDir(), ".codexuse", "p");
+  return import_node_path6.default.join(resolveHomeDir(), ".codexuse", "p");
 }
 async function ensureProfileCodexHomesRoot() {
   const root = resolveProfileCodexHomesRoot();
-  const parent = import_node_path5.default.dirname(root);
+  const parent = import_node_path6.default.dirname(root);
   await (0, import_promises2.mkdir)(parent, { recursive: true, mode: 448 });
   await (0, import_promises2.mkdir)(root, { recursive: true, mode: 448 });
   if (process.platform !== "win32") {
@@ -5685,13 +6398,13 @@ async function ensureProfileCodexHomesRoot() {
   return root;
 }
 function resolveLegacyProfileCodexHomesRoot() {
-  return import_node_path5.default.join(getUserDataDir(), "profile-homes");
+  return import_node_path6.default.join(getUserDataDir(), "profile-homes");
 }
 async function migrateProfileCodexHomeDir(profileHomeId) {
-  const legacy = import_node_path5.default.join(resolveLegacyProfileCodexHomesRoot(), profileHomeId);
+  const legacy = import_node_path6.default.join(resolveLegacyProfileCodexHomesRoot(), profileHomeId);
   const current = resolveCurrentProfileCodexHomeDir(profileHomeId);
-  const currentExists = (0, import_node_fs3.existsSync)(current);
-  const legacyExists = (0, import_node_fs3.existsSync)(legacy);
+  const currentExists = (0, import_node_fs5.existsSync)(current);
+  const legacyExists = (0, import_node_fs5.existsSync)(legacy);
   if (currentExists && legacyExists) {
     return current;
   }
@@ -5767,7 +6480,7 @@ var import_toml = __toESM(require_toml(), 1);
 // ../../packages/runtime-codex/src/codex/config-metadata.ts
 var import_node_child_process4 = require("child_process");
 var import_promises3 = require("fs/promises");
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 var CONFIG_SCHEMA_URL = "https://raw.githubusercontent.com/openai/codex/main/codex-rs/core/config.schema.json";
 var METADATA_CACHE_TTL_MS = 6e4;
 var FALLBACK_SCHEMA_TOP_LEVEL_KEYS = [
@@ -5953,8 +6666,8 @@ function parseSchemaKeys(schemaRaw) {
 async function readSchemaFromLocal() {
   const candidates = [
     process.env.CODEX_CONFIG_SCHEMA_PATH,
-    import_node_path6.default.join(process.cwd(), "codex-rs", "core", "config.schema.json"),
-    import_node_path6.default.join(process.cwd(), "node_modules", "@openai", "codex", "codex-rs", "core", "config.schema.json")
+    import_node_path7.default.join(process.cwd(), "codex-rs", "core", "config.schema.json"),
+    import_node_path7.default.join(process.cwd(), "node_modules", "@openai", "codex", "codex-rs", "core", "config.schema.json")
   ].filter((candidate) => Boolean(candidate));
   for (const candidate of candidates) {
     try {
@@ -6059,7 +6772,7 @@ async function getCodexConfigMetadata(forceRefresh = false) {
 
 // ../../packages/runtime-codex/src/codex/config-io.ts
 var import_promises4 = require("fs/promises");
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 
 // ../../packages/runtime-codex/src/codex/config-presets.ts
 var DEFAULT_CONFIG_TEMPLATE = [
@@ -6102,10 +6815,10 @@ var YOLO_PRESET = {
 
 // ../../packages/runtime-codex/src/codex/config-io.ts
 function getConfigPath(options) {
-  return import_node_path7.default.join(resolveCodexHomeDir(options), "config.toml");
+  return import_node_path8.default.join(resolveCodexHomeDir(options), "config.toml");
 }
 async function ensureConfigDirExists(filePath) {
-  const dir = import_node_path7.default.dirname(filePath);
+  const dir = import_node_path8.default.dirname(filePath);
   await (0, import_promises4.mkdir)(dir, { recursive: true });
 }
 function normalizeLineEndings(content) {
@@ -6663,82 +7376,6 @@ async function saveCodexConfigContent(content, options) {
   return buildSnapshot(normalized, true, options);
 }
 
-// ../../packages/runtime-app-state/src/storage/fileLock.ts
-var import_node_fs4 = require("fs");
-var import_node_path8 = __toESM(require("path"), 1);
-function isSqliteBusyError2(error) {
-  if (!error || typeof error !== "object") {
-    return false;
-  }
-  const value3 = error;
-  if (value3.cause && value3.cause !== error && isSqliteBusyError2(value3.cause)) {
-    return true;
-  }
-  if (value3.error && value3.error !== error && isSqliteBusyError2(value3.error)) {
-    return true;
-  }
-  const message = typeof value3.message === "string" ? value3.message.toLowerCase() : String(error).toLowerCase();
-  return value3.code === "SQLITE_BUSY" || value3.errno === 5 || message.includes("sqlite_busy") || message.includes("database is locked");
-}
-async function openLockDatabase(databasePath) {
-  await import_node_fs4.promises.mkdir(import_node_path8.default.dirname(databasePath), { recursive: true, mode: 448 });
-  const sqlite = process.versions.bun ? await Function("return import('bun:sqlite')")() : await Function("return import('node:sqlite')")();
-  const database = process.versions.bun ? new sqlite.Database(databasePath) : new sqlite.DatabaseSync(databasePath);
-  try {
-    if (process.platform !== "win32") {
-      await import_node_fs4.promises.chmod(databasePath, 384);
-    }
-    return {
-      exec: database.exec.bind(database),
-      close: database.close.bind(database)
-    };
-  } catch (error) {
-    database.close();
-    throw error;
-  }
-}
-async function acquireCrossProcessFileLockTransaction(filePath, mode) {
-  const databasePath = `${import_node_path8.default.resolve(filePath)}.codexuse-lock.sqlite`;
-  let database = null;
-  try {
-    database = await openLockDatabase(databasePath);
-    database.exec("PRAGMA busy_timeout = 1000;");
-    database.exec("CREATE TABLE IF NOT EXISTS codexuse_file_lock (id INTEGER PRIMARY KEY);");
-    database.exec("PRAGMA busy_timeout = 0;");
-    if (mode === "write") {
-      database.exec("BEGIN EXCLUSIVE;");
-    } else {
-      database.exec("BEGIN;");
-      database.exec("SELECT COUNT(*) FROM codexuse_file_lock;");
-    }
-  } catch (error) {
-    database?.close();
-    if (isSqliteBusyError2(error)) {
-      return null;
-    }
-    throw error;
-  }
-  const acquiredDatabase = database;
-  let released = false;
-  return async () => {
-    if (released) {
-      return;
-    }
-    released = true;
-    try {
-      acquiredDatabase.exec("ROLLBACK;");
-    } finally {
-      acquiredDatabase.close();
-    }
-  };
-}
-async function acquireCrossProcessFileLock(filePath) {
-  return acquireCrossProcessFileLockTransaction(filePath, "write");
-}
-async function acquireCrossProcessFileReadLock(filePath) {
-  return acquireCrossProcessFileLockTransaction(filePath, "read");
-}
-
 // ../../packages/shared/src/core/logger.ts
 var isTestEnv = process.env.NODE_ENV === "test" || process.env.VITEST === "true" || process.env.VITEST === "1";
 function isMocked(fn2) {
@@ -23523,11 +24160,11 @@ function authWritebackPaths(filePath) {
   };
 }
 function fingerprintAuth(content) {
-  return (0, import_node_crypto8.createHash)("sha256").update(content).digest("hex");
+  return (0, import_node_crypto9.createHash)("sha256").update(content).digest("hex");
 }
 async function readOptionalFile(filePath) {
   try {
-    return await import_node_fs5.promises.readFile(filePath, "utf8");
+    return await import_node_fs6.promises.readFile(filePath, "utf8");
   } catch (error) {
     const code = error && typeof error === "object" && "code" in error ? error.code : null;
     if (code === "ENOENT") return null;
@@ -23538,9 +24175,9 @@ async function writeAtomicPath(filePath, content) {
   const dir = import_node_path9.default.dirname(filePath);
   const tempPath = import_node_path9.default.join(
     dir,
-    `.${import_node_path9.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto8.randomUUID)()}.tmp`
+    `.${import_node_path9.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto9.randomUUID)()}.tmp`
   );
-  const handle = await import_node_fs5.promises.open(tempPath, "wx", 384);
+  const handle = await import_node_fs6.promises.open(tempPath, "wx", 384);
   try {
     await handle.writeFile(content, "utf8");
     await handle.sync();
@@ -23548,9 +24185,9 @@ async function writeAtomicPath(filePath, content) {
     await handle.close();
   }
   try {
-    await import_node_fs5.promises.rename(tempPath, filePath);
+    await import_node_fs6.promises.rename(tempPath, filePath);
     if (process.platform !== "win32") {
-      const dirHandle = await import_node_fs5.promises.open(dir, "r");
+      const dirHandle = await import_node_fs6.promises.open(dir, "r");
       try {
         await dirHandle.sync();
       } finally {
@@ -23558,16 +24195,16 @@ async function writeAtomicPath(filePath, content) {
       }
     }
   } finally {
-    await import_node_fs5.promises.rm(tempPath, { force: true }).catch(() => void 0);
+    await import_node_fs6.promises.rm(tempPath, { force: true }).catch(() => void 0);
   }
 }
 async function installAuthFileIfAbsent(filePath, content) {
   const dir = import_node_path9.default.dirname(filePath);
   const tempPath = import_node_path9.default.join(
     dir,
-    `.${import_node_path9.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto8.randomUUID)()}.install`
+    `.${import_node_path9.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto9.randomUUID)()}.install`
   );
-  const handle = await import_node_fs5.promises.open(tempPath, "wx", 384);
+  const handle = await import_node_fs6.promises.open(tempPath, "wx", 384);
   try {
     await handle.writeFile(content, "utf8");
     await handle.sync();
@@ -23575,25 +24212,25 @@ async function installAuthFileIfAbsent(filePath, content) {
     await handle.close();
   }
   try {
-    await import_node_fs5.promises.link(tempPath, filePath);
+    await import_node_fs6.promises.link(tempPath, filePath);
   } finally {
-    await import_node_fs5.promises.rm(tempPath, { force: true }).catch(() => void 0);
+    await import_node_fs6.promises.rm(tempPath, { force: true }).catch(() => void 0);
   }
 }
 async function linkAuthFileIfAbsent(sourcePath, targetPath) {
-  await import_node_fs5.promises.link(sourcePath, targetPath);
+  await import_node_fs6.promises.link(sourcePath, targetPath);
 }
 async function hasExternalOpenFileHandle(filePath) {
   if (process.platform === "linux") {
     let target;
     try {
-      target = await import_node_fs5.promises.stat(filePath);
+      target = await import_node_fs6.promises.stat(filePath);
     } catch {
       return true;
     }
     let processes;
     try {
-      processes = await import_node_fs5.promises.readdir("/proc", { withFileTypes: true });
+      processes = await import_node_fs6.promises.readdir("/proc", { withFileTypes: true });
     } catch {
       return true;
     }
@@ -23604,7 +24241,7 @@ async function hasExternalOpenFileHandle(filePath) {
       }
       const processPath = `/proc/${entry.name}`;
       try {
-        const processStats = await import_node_fs5.promises.stat(processPath);
+        const processStats = await import_node_fs6.promises.stat(processPath);
         if (currentUid !== void 0 && processStats.uid !== currentUid) {
           continue;
         }
@@ -23613,7 +24250,7 @@ async function hasExternalOpenFileHandle(filePath) {
       }
       let descriptors;
       try {
-        descriptors = await import_node_fs5.promises.readdir(`${processPath}/fd`);
+        descriptors = await import_node_fs6.promises.readdir(`${processPath}/fd`);
       } catch (error) {
         const code = error && typeof error === "object" && "code" in error ? error.code : null;
         if (code === "ENOENT" || code === "ESRCH") continue;
@@ -23621,7 +24258,7 @@ async function hasExternalOpenFileHandle(filePath) {
       }
       for (const descriptor2 of descriptors) {
         try {
-          const descriptorStats = await import_node_fs5.promises.stat(`${processPath}/fd/${descriptor2}`);
+          const descriptorStats = await import_node_fs6.promises.stat(`${processPath}/fd/${descriptor2}`);
           if (descriptorStats.dev === target.dev && descriptorStats.ino === target.ino) {
             return true;
           }
@@ -23668,9 +24305,9 @@ async function hasExternalOpenFileHandle(filePath) {
 async function cleanupAuthWriteback(filePath) {
   const paths = authWritebackPaths(filePath);
   await Promise.all([
-    import_node_fs5.promises.rm(paths.manifest, { force: true }),
-    import_node_fs5.promises.rm(paths.backup, { force: true }),
-    import_node_fs5.promises.rm(paths.replaced, { force: true })
+    import_node_fs6.promises.rm(paths.manifest, { force: true }),
+    import_node_fs6.promises.rm(paths.backup, { force: true }),
+    import_node_fs6.promises.rm(paths.replaced, { force: true })
   ]);
 }
 async function rollbackAuthWriteback(filePath, manifest) {
@@ -23691,8 +24328,8 @@ async function rollbackAuthWriteback(filePath, manifest) {
       "Codex auth changed outside CodexUse during writeback rollback; recovery files were preserved."
     );
   }
-  await import_node_fs5.promises.rename(filePath, paths.replaced);
-  if (fingerprintAuth(await import_node_fs5.promises.readFile(paths.replaced, "utf8")) !== manifest.targetFingerprint) {
+  await import_node_fs6.promises.rename(filePath, paths.replaced);
+  if (fingerprintAuth(await import_node_fs6.promises.readFile(paths.replaced, "utf8")) !== manifest.targetFingerprint) {
     const replaced = await readOptionalFile(paths.replaced);
     if (await readOptionalFile(filePath) === null && replaced !== null) {
       await installAuthFileIfAbsent(filePath, replaced);
@@ -23729,7 +24366,7 @@ async function replaceAuthFileIfCurrent(filePath, expectedCurrent, replacement)
   await writeAtomicPath(paths.manifest, JSON.stringify(manifest));
   let committed = false;
   try {
-    await import_node_fs5.promises.rename(filePath, paths.backup);
+    await import_node_fs6.promises.rename(filePath, paths.backup);
     if (await readOptionalFile(paths.backup) !== expectedCurrent) {
       throw new Error("Codex auth changed while writeback began.");
     }
@@ -23829,7 +24466,7 @@ async function acquireCodexAuthFileReadLock(filePath) {
 async function readAuthFileCached(filePath) {
   let stats;
   try {
-    stats = await import_node_fs5.promises.stat(filePath);
+    stats = await import_node_fs6.promises.stat(filePath);
   } catch {
     authFileCache.delete(filePath);
     return null;
@@ -23838,7 +24475,7 @@ async function readAuthFileCached(filePath) {
   if (cached2 && cached2.mtimeMs === stats.mtimeMs && cached2.size === stats.size) {
     return cached2.content;
   }
-  const content = await import_node_fs5.promises.readFile(filePath, "utf8");
+  const content = await import_node_fs6.promises.readFile(filePath, "utf8");
   authFileCache.set(filePath, {
     mtimeMs: stats.mtimeMs,
     size: stats.size,
@@ -23857,7 +24494,7 @@ async function writeAuthFileCached(filePath, content, expectedCurrent, options =
     );
     if (!written) return false;
     try {
-      const stats = await import_node_fs5.promises.stat(filePath);
+      const stats = await import_node_fs6.promises.stat(filePath);
       authFileCache.set(filePath, {
         mtimeMs: stats.mtimeMs,
         size: stats.size,
@@ -23996,13 +24633,13 @@ function resolveRpcAuthPath(envOverride, authPath) {
 async function fetchRateLimitsViaRpc(envOverride, options = {}) {
   const binaryPath = options.codexPath ?? await requireCodexCli();
   const sourceAuthPath = resolveRpcAuthPath(envOverride, options.authPath);
-  const tempHome = await import_node_fs5.promises.mkdtemp(import_node_path9.default.join(import_node_os3.default.tmpdir(), "codex-rpc-"));
+  const tempHome = await import_node_fs6.promises.mkdtemp(import_node_path9.default.join(import_node_os3.default.tmpdir(), "codex-rpc-"));
   const tempAuthPath = import_node_path9.default.join(tempHome, "auth.json");
   let initialSourceAuth;
   try {
     const authLock = await acquireCodexAuthFileReadLock(sourceAuthPath);
     if (!authLock) {
-      await import_node_fs5.promises.rm(tempHome, { recursive: true, force: true });
+      await import_node_fs6.promises.rm(tempHome, { recursive: true, force: true });
       return null;
     }
     try {
@@ -24011,15 +24648,15 @@ async function fetchRateLimitsViaRpc(envOverride, options = {}) {
       await authLock.release();
     }
     if (!initialSourceAuth) {
-      await import_node_fs5.promises.rm(tempHome, { recursive: true, force: true });
+      await import_node_fs6.promises.rm(tempHome, { recursive: true, force: true });
       return null;
     }
-    await import_node_fs5.promises.writeFile(tempAuthPath, initialSourceAuth, {
+    await import_node_fs6.promises.writeFile(tempAuthPath, initialSourceAuth, {
       encoding: "utf8",
       mode: 384
     });
   } catch {
-    await import_node_fs5.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
+    await import_node_fs6.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
     });
     return null;
   }
@@ -24086,7 +24723,7 @@ async function fetchRateLimitsViaRpc(envOverride, options = {}) {
     rl.close();
     await stopChildAndWait(child);
     try {
-      const updatedAuth = await import_node_fs5.promises.readFile(tempAuthPath, "utf8");
+      const updatedAuth = await import_node_fs6.promises.readFile(tempAuthPath, "utf8");
       if (updatedAuth.trim().length > 0) {
         const currentSourceAuth = await readAuthFileCached(sourceAuthPath);
         if (shouldWriteBackAuth(initialSourceAuth, currentSourceAuth, updatedAuth)) {
@@ -24115,7 +24752,7 @@ async function fetchRateLimitsViaRpc(envOverride, options = {}) {
     } catch (error) {
       logWarn("Failed to sync refreshed auth after rate-limit probe:", error);
     }
-    await import_node_fs5.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
+    await import_node_fs6.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
     });
   }
 }
@@ -24129,7 +24766,7 @@ async function activateResetWindowViaRpc(envOverride, options = {}) {
 }
 async function activateResetWindowViaRpcIsolated(envOverride, options, sourceAuthPath) {
   const binaryPath = options.codexPath ?? await requireCodexCli();
-  const tempHome = await import_node_fs5.promises.mkdtemp(
+  const tempHome = await import_node_fs6.promises.mkdtemp(
     import_node_path9.default.join(import_node_os3.default.tmpdir(), "codex-activation-")
   );
   const tempAuthPath = import_node_path9.default.join(tempHome, "auth.json");
@@ -24137,7 +24774,7 @@ async function activateResetWindowViaRpcIsolated(envOverride, options, sourceAut
   try {
     const authLock = await acquireCodexAuthFileReadLock(sourceAuthPath);
     if (!authLock) {
-      await import_node_fs5.promises.rm(tempHome, { recursive: true, force: true });
+      await import_node_fs6.promises.rm(tempHome, { recursive: true, force: true });
       return { status: "skipped", reason: "auth-busy" };
     }
     try {
@@ -24146,16 +24783,16 @@ async function activateResetWindowViaRpcIsolated(envOverride, options, sourceAut
       await authLock.release();
     }
     if (!initialSourceAuth) {
-      await import_node_fs5.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
+      await import_node_fs6.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
       });
       return { status: "skipped", reason: "auth-missing" };
     }
-    await import_node_fs5.promises.writeFile(tempAuthPath, initialSourceAuth, {
+    await import_node_fs6.promises.writeFile(tempAuthPath, initialSourceAuth, {
       encoding: "utf8",
       mode: 384
     });
   } catch {
-    await import_node_fs5.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
+    await import_node_fs6.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
     });
     return { status: "skipped", reason: "auth-missing" };
   }
@@ -24168,7 +24805,7 @@ async function activateResetWindowViaRpcIsolated(envOverride, options, sourceAut
   } catch {
   }
   const activationModel = resolveActivationModel(configuredModel);
-  await import_node_fs5.promises.writeFile(
+  await import_node_fs6.promises.writeFile(
     import_node_path9.default.join(tempHome, "config.toml"),
     `model = ${JSON.stringify(activationModel)}
 `,
@@ -24306,7 +24943,7 @@ async function activateResetWindowViaRpcIsolated(envOverride, options, sourceAut
     rl.close();
     await stopChildAndWait(child);
     try {
-      const updatedAuth = await import_node_fs5.promises.readFile(tempAuthPath, "utf8");
+      const updatedAuth = await import_node_fs6.promises.readFile(tempAuthPath, "utf8");
       if (updatedAuth.trim().length > 0) {
         const currentSourceAuth = await readAuthFileCached(sourceAuthPath);
         if (shouldWriteBackAuth(initialSourceAuth, currentSourceAuth, updatedAuth)) {
@@ -24341,7 +24978,7 @@ async function activateResetWindowViaRpcIsolated(envOverride, options, sourceAut
     } catch (error) {
       writebackError = error instanceof Error ? error : new Error(String(error));
     }
-    await import_node_fs5.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
+    await import_node_fs6.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
     });
   }
   if (activationError && writebackError) {
@@ -24364,13 +25001,13 @@ async function activateResetWindowViaRpcIsolated(envOverride, options, sourceAut
 
 // ../../packages/runtime-codex/src/codex/officialAppRestart.ts
 var import_node_child_process6 = require("child_process");
-var import_node_crypto9 = require("crypto");
-var import_node_fs7 = require("fs");
+var import_node_crypto10 = require("crypto");
+var import_node_fs8 = require("fs");
 var import_node_os4 = require("os");
 var import_node_path11 = __toESM(require("path"), 1);
 
 // ../../packages/runtime-codex/src/codex/threadUsage.ts
-var import_node_fs6 = require("fs");
+var import_node_fs7 = require("fs");
 var import_node_path10 = __toESM(require("path"), 1);
 var ROLLOUT_DIRS = ["sessions", "archived_sessions"];
 var SQLITE_EXTENSIONS = /* @__PURE__ */ new Set([".db", ".sqlite", ".sqlite3"]);
@@ -24383,7 +25020,7 @@ async function collectRolloutFiles(root) {
   async function visit(dir) {
     let entries3;
     try {
-      entries3 = await import_node_fs6.promises.readdir(dir, {
+      entries3 = await import_node_fs7.promises.readdir(dir, {
         withFileTypes: true,
         encoding: "utf8"
       });
@@ -24411,7 +25048,7 @@ async function collectRolloutFiles(root) {
 async function collectRolloutFilesStrict(root) {
   const files = [];
   async function visit(dir) {
-    const entries3 = await import_node_fs6.promises.readdir(dir, {
+    const entries3 = await import_node_fs7.promises.readdir(dir, {
       withFileTypes: true,
       encoding: "utf8"
     });
@@ -24436,7 +25073,7 @@ async function readOfficialCodexRolloutActivityHeat(profileHome) {
     for (const dirname of ROLLOUT_DIRS) {
       const root = import_node_path10.default.join(profileHome, dirname);
       try {
-        await import_node_fs6.promises.access(root);
+        await import_node_fs7.promises.access(root);
       } catch (error) {
         if (error.code === "ENOENT") {
           continue;
@@ -24445,7 +25082,7 @@ async function readOfficialCodexRolloutActivityHeat(profileHome) {
       }
       const files = await collectRolloutFilesStrict(root);
       for (const file of files) {
-        const stat2 = await import_node_fs6.promises.stat(file);
+        const stat2 = await import_node_fs7.promises.stat(file);
         if (Number.isFinite(stat2.mtimeMs)) {
           latestUpdatedAtMs = Math.max(latestUpdatedAtMs ?? 0, stat2.mtimeMs);
         }
@@ -24473,7 +25110,7 @@ async function findRolloutFileByScan(profileHome, threadId) {
       if (!variants.some((variant) => basename.includes(variant))) {
         continue;
       }
-      const stat2 = await import_node_fs6.promises.stat(file).catch(() => null);
+      const stat2 = await import_node_fs7.promises.stat(file).catch(() => null);
       const updatedAtMs = stat2 && Number.isFinite(stat2.mtimeMs) ? stat2.mtimeMs : null;
       if (!best || (updatedAtMs ?? 0) > (best.updatedAtMs ?? 0) || (updatedAtMs ?? 0) === (best.updatedAtMs ?? 0) && file > best.path) {
         best = { path: file, updatedAtMs };
@@ -24551,7 +25188,7 @@ async function collectSessionDatabasePaths(profileHome, sqliteHome = profileHome
   const paths = [];
   const sqliteDir = import_node_path10.default.join(sqliteHome, "sqlite");
   try {
-    const entries3 = await import_node_fs6.promises.readdir(sqliteDir, {
+    const entries3 = await import_node_fs7.promises.readdir(sqliteDir, {
       withFileTypes: true,
       encoding: "utf8"
     });
@@ -24633,7 +25270,7 @@ function queryThreadRecordFromTable(db, profileHome, threadId, config) {
 }
 async function readThreadRecordFromDb(profileHome, dbPath, threadId) {
   try {
-    await import_node_fs6.promises.access(dbPath);
+    await import_node_fs7.promises.access(dbPath);
   } catch {
     return null;
   }
@@ -25053,7 +25690,7 @@ function hashProfileKey(profileKey) {
   if (!profileKey) {
     return null;
   }
-  return (0, import_node_crypto9.createHash)("sha256").update(profileKey).digest("hex").slice(0, 12);
+  return (0, import_node_crypto10.createHash)("sha256").update(profileKey).digest("hex").slice(0, 12);
 }
 function sanitizeOfficialCodexOverlayActionTargetsForRenderer(targets) {
   const sanitized = [];
@@ -28665,7 +29302,7 @@ async function runCdpCommandSequence(debuggerUrl, commands, timeoutMs = CODEX_CD
   });
 }
 async function verifyCdpBindingRoundTrip(debuggerUrl) {
-  const nonce = (0, import_node_crypto9.randomUUID)();
+  const nonce = (0, import_node_crypto10.randomUUID)();
   const expression = `(() => {
     const binding = window[${JSON.stringify(CODEXUSE_BRIDGE_BINDING_NAME)}];
     if (typeof binding !== "function") return false;
@@ -29088,7 +29725,7 @@ async function startOfficialCodexBridgeActionListenerOnce(args2) {
   let closeNotified = false;
   let echoReceived = false;
   const requiredCommandIds = /* @__PURE__ */ new Set();
-  const echoId = (0, import_node_crypto9.randomUUID)();
+  const echoId = (0, import_node_crypto10.randomUUID)();
   const readyTimeout = setTimeout(() => {
     settleReady(false);
     try {
@@ -29162,7 +29799,7 @@ async function startOfficialCodexBridgeActionListenerOnce(args2) {
     }
   };
   bridgeActionListenerVerifiers.set(args2.debuggerUrl, async () => {
-    const id2 = (0, import_node_crypto9.randomUUID)();
+    const id2 = (0, import_node_crypto10.randomUUID)();
     return await new Promise((resolve2) => {
       const waiters = bridgeActionListenerHealthWaiters.get(args2.debuggerUrl) ?? /* @__PURE__ */ new Map();
       bridgeActionListenerHealthWaiters.set(args2.debuggerUrl, waiters);
@@ -29710,7 +30347,7 @@ async function recordOfficialCodexActivity(input) {
   };
   const finite2 = (value3, min4, max4) => typeof value3 === "number" && Number.isFinite(value3) ? Math.max(min4, Math.min(max4, value3)) : null;
   const entry = {
-    id: (0, import_node_crypto9.randomUUID)(),
+    id: (0, import_node_crypto10.randomUUID)(),
     at: now2.toISOString(),
     kind: input.kind,
     status: bounded(input.status, 80) ?? "unknown",
@@ -30713,7 +31350,7 @@ var devToolsActivePortPaths = (appUserDataDir) => {
 };
 var readDevToolsActivePort = async (filePath) => {
   try {
-    const text = await import_node_fs7.promises.readFile(filePath, "utf8");
+    const text = await import_node_fs8.promises.readFile(filePath, "utf8");
     const port = Number(text.split(/\r?\n/, 1)[0]);
     if (!Number.isInteger(port) || port <= 0 || port >= 65536) {
       return null;
@@ -30750,7 +31387,7 @@ function classifyOpenCodexLaunchFailure(error) {
 }
 async function openCodexWithProfileHome(candidate, profileHome, profileName, previousPids, options = {}) {
   const executablePath = getMainExecutablePath(candidate);
-  if (!(0, import_node_fs7.existsSync)(executablePath)) {
+  if (!(0, import_node_fs8.existsSync)(executablePath)) {
     return {
       opened: false,
       pid: null,
@@ -30768,7 +31405,7 @@ async function openCodexWithProfileHome(candidate, profileHome, profileName, pre
   let child;
   try {
     if (appUserDataDir) {
-      (0, import_node_fs7.mkdirSync)(appUserDataDir, { recursive: true });
+      (0, import_node_fs8.mkdirSync)(appUserDataDir, { recursive: true });
     }
     child = (0, import_node_child_process6.spawn)(
       "/usr/bin/open",
@@ -30923,7 +31560,7 @@ function resolveCodexLaunchHome(profileHome) {
 }
 async function readBundleString(appPath, key) {
   const plistPath = import_node_path11.default.join(appPath, "Contents", "Info.plist");
-  if (!(0, import_node_fs7.existsSync)(plistPath)) {
+  if (!(0, import_node_fs8.existsSync)(plistPath)) {
     return null;
   }
   const result2 = await runCommand2("/usr/bin/plutil", [
@@ -30953,7 +31590,7 @@ function officialCodexAppPriority(appPath) {
 async function collectCodexAppCandidates(rawPaths) {
   const candidates = [];
   for (const appPath of rawPaths) {
-    if (!(0, import_node_fs7.existsSync)(appPath) || !OFFICIAL_CODEX_APP_NAMES.includes(import_node_path11.default.basename(appPath)) || !(0, import_node_fs7.existsSync)(import_node_path11.default.join(appPath, "Contents", "Resources", "codex"))) {
+    if (!(0, import_node_fs8.existsSync)(appPath) || !OFFICIAL_CODEX_APP_NAMES.includes(import_node_path11.default.basename(appPath)) || !(0, import_node_fs8.existsSync)(import_node_path11.default.join(appPath, "Contents", "Resources", "codex"))) {
       continue;
     }
     const bundleId = await readBundleString(appPath, "CFBundleIdentifier");
@@ -31065,7 +31702,7 @@ function sharedCodexLaunchOptions(useDefaultUserData, profileIdentity) {
   const userDataDir = !useDefaultUserData && profileIdentity ? import_node_path11.default.join(
     SHARED_CODEX_HOME,
     "codex-app-user-data",
-    (0, import_node_crypto9.createHash)("sha256").update(profileIdentity).digest("hex").slice(0, 16)
+    (0, import_node_crypto10.createHash)("sha256").update(profileIdentity).digest("hex").slice(0, 16)
   ) : void 0;
   return {
     useDefaultUserData,
@@ -33476,7 +34113,7 @@ async function attemptOfficialCodexManagedLiveLogin(args2) {
   }
 }
 async function applyOfficialCodexLiveAccountSwitchOnce(options = {}, takeoverTrace = {
-  operationId: (0, import_node_crypto9.randomUUID)(),
+  operationId: (0, import_node_crypto10.randomUUID)(),
   attempt: 1
 }) {
   let expectedWindowPreflight = options.expectedWindowPreflight;
@@ -34544,7 +35181,7 @@ async function applyOfficialCodexLiveAccountSwitchOnce(options = {}, takeoverTra
 }
 function applyOfficialCodexLiveAccountSwitch(options = {}) {
   return enqueueProfileAction("shared-window", async () => {
-    const operationId = (0, import_node_crypto9.randomUUID)();
+    const operationId = (0, import_node_crypto10.randomUUID)();
     let result2 = await applyOfficialCodexLiveAccountSwitchOnce(options, {
       operationId,
       attempt: 1
@@ -35269,7 +35906,7 @@ async function launchOfficialCodexProfileInstanceOnce(options) {
 }
 
 // ../../packages/runtime-app-state/src/app/profileHomeMutationCoordinator.ts
-var import_node_crypto10 = require("crypto");
+var import_node_crypto11 = require("crypto");
 
 // ../../packages/runtime-app-state/src/app/processOwner.ts
 var import_node_child_process7 = require("child_process");
@@ -35307,12 +35944,12 @@ function isProcessEpochAlive(pid, expectedStartedAt) {
 // ../../packages/runtime-app-state/src/app/profileHomeMutationCoordinator.ts
 var PROFILE_HOME_MUTATION_TTL_MS = 10 * 60 * 1e3;
 var PROFILE_HOME_MUTATION_RENEW_MS = 30 * 1e3;
-var PROCESS_OWNER_ID = (0, import_node_crypto10.randomUUID)();
+var PROCESS_OWNER_ID = (0, import_node_crypto11.randomUUID)();
 var PROCESS_STARTED_AT = readProcessStartedAt(process.pid);
 var activeRenewals = /* @__PURE__ */ new Map();
 async function acquireProfileHomeMutationIntent(input) {
   const now2 = Date.now();
-  const operationId = (0, import_node_crypto10.randomUUID)();
+  const operationId = (0, import_node_crypto11.randomUUID)();
   const renewal = {
     timer: void 0,
     pending: Promise.resolve(),
@@ -35394,7 +36031,7 @@ async function releaseProfileHomeMutationIntent(homeId, operationId) {
 }
 
 // ../../packages/runtime-profiles/src/profiles/rate-limit-cache.ts
-var import_node_fs8 = require("fs");
+var import_node_fs9 = require("fs");
 var import_node_path12 = __toESM(require("path"), 1);
 var memorySnapshots = /* @__PURE__ */ new Map();
 var persistedSnapshotWriteLock = Promise.resolve();
@@ -35408,7 +36045,7 @@ function snapshotCachePath() {
 async function loadPersistedSnapshots() {
   let raw;
   try {
-    raw = (await import_node_fs8.promises.readFile(snapshotCachePath(), "utf8")).trim();
+    raw = (await import_node_fs9.promises.readFile(snapshotCachePath(), "utf8")).trim();
   } catch {
     return /* @__PURE__ */ new Map();
   }
@@ -35452,13 +36089,13 @@ async function writePersistedSnapshots(snapshots) {
     2
   );
   try {
-    await import_node_fs8.promises.mkdir(import_node_path12.default.dirname(filePath), { recursive: true });
-    await import_node_fs8.promises.writeFile(tmpPath, `${payload}
+    await import_node_fs9.promises.mkdir(import_node_path12.default.dirname(filePath), { recursive: true });
+    await import_node_fs9.promises.writeFile(tmpPath, `${payload}
 `, "utf8");
-    await import_node_fs8.promises.rename(tmpPath, filePath);
+    await import_node_fs9.promises.rename(tmpPath, filePath);
   } catch {
     try {
-      await import_node_fs8.promises.rm(tmpPath, { force: true });
+      await import_node_fs9.promises.rm(tmpPath, { force: true });
     } catch {
     }
   }
@@ -35523,7 +36160,7 @@ var AUTH_MUTATION_MANIFEST_NAME = ".codexuse-auth-transaction.json";
 var AUTH_MUTATION_BACKUP_NAME = ".codexuse-auth-transaction.backup";
 var AUTH_MUTATION_REPLACED_NAME = ".codexuse-auth-transaction.replaced";
 var PROFILE_HOME_MUTATION_MARKER_TTL_MS = 10 * 60 * 1e3;
-var PROCESS_OWNER_ID2 = (0, import_node_crypto11.randomUUID)();
+var PROCESS_OWNER_ID2 = (0, import_node_crypto12.randomUUID)();
 var PROCESS_STARTED_AT2 = readProcessStartedAt(process.pid);
 var globalAuthSwapLock = Promise.resolve();
 var profileOperationLocks = /* @__PURE__ */ new Map();
@@ -36339,8 +36976,14 @@ var ProfileManager = class {
     const homeIdsByProfileName = /* @__PURE__ */ new Map();
     const profileNamesByHomeId = /* @__PURE__ */ new Map();
     for (const [profileName, raw] of Object.entries(source)) {
-      const homeId = normalizeProfileHomeId(raw.homeId);
-      if (!homeId) {
+      let record2;
+      try {
+        record2 = this.fromStateRecord(profileName, raw);
+      } catch {
+        continue;
+      }
+      const homeId = record2 ? normalizeProfileHomeId(raw.homeId) : null;
+      if (!record2 || !homeId) {
         continue;
       }
       const collisionKey = homeId.toLowerCase();
@@ -36363,7 +37006,7 @@ var ProfileManager = class {
       let attempt = 0;
       let homeId;
       do {
-        homeId = `legacy-${(0, import_node_crypto11.createHash)("sha256").update(profileName).update("\0").update(String(attempt)).digest("hex").slice(0, 32)}`;
+        homeId = `legacy-${(0, import_node_crypto12.createHash)("sha256").update(profileName).update("\0").update(String(attempt)).digest("hex").slice(0, 32)}`;
         attempt += 1;
       } while (profileNamesByHomeId.has(homeId.toLowerCase()));
       homeIdsByProfileName.set(profileName, homeId);
@@ -36479,17 +37122,17 @@ var ProfileManager = class {
   }
   async reconcileProfileHomeLocationConflicts(source) {
     for (const [profileName, raw] of Object.entries(source)) {
-      const record2 = this.fromStateRecord(profileName, raw);
-      if (!record2) {
-        continue;
-      }
-      const conflict = findProfileCodexHomeLocationConflict(record2.homeId);
-      if (!conflict) {
-        continue;
-      }
-      const currentAuthPath = (0, import_path2.join)(conflict.current, "auth.json");
-      const legacyAuthPath = (0, import_path2.join)(conflict.legacy, "auth.json");
       try {
+        const record2 = this.fromStateRecord(profileName, raw);
+        if (!record2) {
+          continue;
+        }
+        const conflict = findProfileCodexHomeLocationConflict(record2.homeId);
+        if (!conflict) {
+          continue;
+        }
+        const currentAuthPath = (0, import_path2.join)(conflict.current, "auth.json");
+        const legacyAuthPath = (0, import_path2.join)(conflict.legacy, "auth.json");
         await this.withProfileAuthFileLock(currentAuthPath, async (currentRaw) => {
           await this.withProfileAuthFileLock(legacyAuthPath, async (legacyRaw) => {
             if (!legacyRaw?.trim()) {
@@ -36573,7 +37216,7 @@ var ProfileManager = class {
     const dir = import_path.default.dirname(filePath);
     const tempPath = import_path.default.join(
       dir,
-      `.${import_path.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto11.randomUUID)()}.tmp`
+      `.${import_path.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto12.randomUUID)()}.tmp`
     );
     await import_fs.promises.mkdir(dir, { recursive: true, mode: 448 });
     if (process.platform !== "win32") {
@@ -36860,7 +37503,7 @@ var ProfileManager = class {
     if (content === null) {
       return null;
     }
-    return (0, import_node_crypto11.createHash)("sha256").update(content).digest("hex");
+    return (0, import_node_crypto12.createHash)("sha256").update(content).digest("hex");
   }
   async readOptionalFile(filePath) {
     try {
@@ -36918,7 +37561,7 @@ var ProfileManager = class {
     const dir = import_path.default.dirname(filePath);
     const tempPath = import_path.default.join(
       dir,
-      `.${import_path.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto11.randomUUID)()}.install`
+      `.${import_path.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto12.randomUUID)()}.install`
     );
     const handle = await import_fs.promises.open(tempPath, "wx", 384);
     try {
@@ -37036,7 +37679,7 @@ var ProfileManager = class {
     });
     const manifest = {
       version: 1,
-      id: (0, import_node_crypto11.randomUUID)(),
+      id: (0, import_node_crypto12.randomUUID)(),
       operation,
       phase: "prepared",
       sourceFingerprint: this.fingerprintAuthContent(sourceRaw),
@@ -37151,22 +37794,43 @@ var ProfileManager = class {
     const byIdentityWorkspace = /* @__PURE__ */ new Map();
     let cacheable = true;
     for (const [profileName, raw] of Object.entries(source)) {
-      const storedRecord = this.fromStateRecord(profileName, raw);
+      let storedRecord;
+      try {
+        storedRecord = this.fromStateRecord(profileName, raw);
+      } catch (error) {
+        logWarn(`Failed to read saved profile '${profileName}':`, error);
+        cacheable = false;
+        continue;
+      }
       if (!storedRecord) {
         continue;
       }
-      const hydration = await this.hydrateProfileRecordWithStatus(storedRecord);
+      let hydration;
+      try {
+        hydration = await this.hydrateProfileRecordWithStatus(storedRecord);
+      } catch (error) {
+        logWarn(
+          `Failed to hydrate profile '${profileName}'; using its saved metadata:`,
+          error
+        );
+        hydration = { record: storedRecord, cacheable: false };
+      }
       const record2 = hydration.record;
       cacheable = cacheable && hydration.cacheable;
       records.push(record2);
-      const identityKey = this.resolveProfileIdentityFromRecord(record2);
-      const workspaceId = record2.workspaceId ?? record2.data.workspace_id ?? DEFAULT_WORKSPACE_ID;
-      const key = this.identityWorkspaceIndexKey(identityKey, workspaceId);
-      const bucket = byIdentityWorkspace.get(key);
-      if (bucket) {
-        bucket.push(record2);
-      } else {
-        byIdentityWorkspace.set(key, [record2]);
+      try {
+        const identityKey = this.resolveProfileIdentityFromRecord(record2);
+        const workspaceId = record2.workspaceId ?? record2.data.workspace_id ?? DEFAULT_WORKSPACE_ID;
+        const key = this.identityWorkspaceIndexKey(identityKey, workspaceId);
+        const bucket = byIdentityWorkspace.get(key);
+        if (bucket) {
+          bucket.push(record2);
+        } else {
+          byIdentityWorkspace.set(key, [record2]);
+        }
+      } catch (error) {
+        logWarn(`Failed to index saved profile '${profileName}':`, error);
+        cacheable = false;
       }
     }
     const index2 = { sourceFingerprint, records, byIdentityWorkspace };
@@ -37737,7 +38401,7 @@ var ProfileManager = class {
     const displayName = typeof options?.displayName === "string" && options.displayName.trim().length > 0 ? options.displayName.trim() : existingRecord?.displayName ?? resolvedName;
     const record2 = {
       name: resolvedName,
-      homeId: existingRecord?.homeId ?? (options?.homeId ? this.normalizeProfileHomeId(options.homeId, resolvedName) : (0, import_node_crypto11.randomUUID)()),
+      homeId: existingRecord?.homeId ?? (options?.homeId ? this.normalizeProfileHomeId(options.homeId, resolvedName) : (0, import_node_crypto12.randomUUID)()),
       cloudHomeId: existingRecord?.cloudHomeId ?? null,
       displayName,
       data,
@@ -37842,7 +38506,7 @@ var ProfileManager = class {
     const safeName = record2.name.replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 48) || "profile";
     const destination = import_path.default.join(
       trashRoot,
-      `CodexUse-${safeName}-${(0, import_node_crypto11.randomUUID)()}`
+      `CodexUse-${safeName}-${(0, import_node_crypto12.randomUUID)()}`
     );
     await import_fs.promises.rename(profileHome, destination);
     return destination;
@@ -38270,7 +38934,7 @@ var ProfileManager = class {
   async acquireProfileRuntimeLease(record2) {
     const leaseDir = this.getProfileRuntimeLeaseDir(record2.homeId);
     const deletingPath = (0, import_path2.join)(leaseDir, ".deleting");
-    const leaseId = (0, import_node_crypto11.randomUUID)();
+    const leaseId = (0, import_node_crypto12.randomUUID)();
     const leasePath = (0, import_path2.join)(leaseDir, `${leaseId}.json`);
     const backupPath = (0, import_path2.join)(leaseDir, `${leaseId}.auth.backup`);
     const releaseIntent = await this.acquireProfileHomeWriteIntent(record2);
@@ -38481,7 +39145,7 @@ var ProfileManager = class {
   async acquireProfileHomeMutationGuard(record2) {
     const leaseDir = this.getProfileRuntimeLeaseDir(record2.homeId);
     const deletingPath = (0, import_path2.join)(leaseDir, ".deleting");
-    const mutationId = (0, import_node_crypto11.randomUUID)();
+    const mutationId = (0, import_node_crypto12.randomUUID)();
     const mutationIntent = await acquireProfileHomeMutationIntent({
       homeId: record2.homeId,
       profileName: record2.name
@@ -38772,7 +39436,18 @@ var ProfileManager = class {
     await this.initialize();
     try {
       const records = await this.listProfileRecords();
-      return records.map((record2) => this.buildProfileFromRow(record2)).filter((profile) => !profile.authMethod || profile.authMethod === "codex-cli").sort((a, b) => {
+      const profiles = [];
+      for (const record2 of records) {
+        try {
+          const profile = this.buildProfileFromRow(record2);
+          if (!profile.authMethod || profile.authMethod === "codex-cli") {
+            profiles.push(profile);
+          }
+        } catch (error) {
+          logWarn(`Failed to build saved profile '${record2.name}':`, error);
+        }
+      }
+      return profiles.sort((a, b) => {
         const aLabel = a.displayName ?? a.name;
         const bLabel = b.displayName ?? b.name;
         const base2 = aLabel.localeCompare(bLabel);
@@ -38780,7 +39455,7 @@ var ProfileManager = class {
       });
     } catch (error) {
       logError("Error reading profiles from disk:", error);
-      return [];
+      throw error;
     }
   }
   async runWithPreparedProfileHome(name, action, options = {}) {
@@ -39822,8 +40497,8 @@ var ProfileManager = class {
         }
         cloudRenamesByOldName.set(renamedExisting.name, name);
       }
-      const homeId = (0, import_node_crypto11.randomUUID)();
-      const cloudHomeId = remoteHomeId || existing?.cloudHomeId || existing?.homeId || renamedExisting?.cloudHomeId || renamedExisting?.homeId || (0, import_node_crypto11.randomUUID)();
+      const homeId = (0, import_node_crypto12.randomUUID)();
+      const cloudHomeId = remoteHomeId || existing?.cloudHomeId || existing?.homeId || renamedExisting?.cloudHomeId || renamedExisting?.homeId || (0, import_node_crypto12.randomUUID)();
       const sourceRecord = renamedExisting ?? existing;
       if (sourceRecord) {
         sourceHomeIdByTargetHomeId.set(homeId, sourceRecord.homeId);
@@ -40118,9 +40793,11 @@ async function listManagedProfiles(profileManager) {
     return labelOrder !== 0 ? labelOrder : left.name.localeCompare(right.name);
   });
 }
-async function getCurrentManagedProfile(profileManager) {
+async function getCurrentManagedProfile(profileManager, activeCodexAuth) {
   const [currentOpenAiProfile, state] = await Promise.all([
-    profileManager.getCurrentProfile(),
+    activeCodexAuth ? Promise.resolve(
+      activeCodexAuth.state === "matched" && activeCodexAuth.profileName ? { name: activeCodexAuth.profileName, trusted: true } : { name: null, trusted: false }
+    ) : profileManager.getCurrentProfile(),
     getAppState()
   ]);
   const lastProfileName = state.app.lastProfileName?.trim() || null;
@@ -40722,13 +41399,13 @@ async function listApiKeys(stateDir) {
   return Object.values(store.apiKeysById).filter((key) => key.revokedAt === null).sort((left, right) => right.createdAt.localeCompare(left.createdAt)).map(accountPoolApiKeyView);
 }
 function hashToken(token) {
-  return (0, import_node_crypto12.createHash)("sha256").update(token).digest("hex");
+  return (0, import_node_crypto13.createHash)("sha256").update(token).digest("hex");
 }
 async function createApiKey(stateDir) {
-  const plaintextToken = `cux_pool_${(0, import_node_crypto12.randomBytes)(24).toString("hex")}`;
+  const plaintextToken = `cux_pool_${(0, import_node_crypto13.randomBytes)(24).toString("hex")}`;
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const keyRecord = {
-    id: (0, import_node_crypto12.randomUUID)(),
+    id: (0, import_node_crypto13.randomUUID)(),
     tokenHash: hashToken(plaintextToken),
     tokenPreview: `${plaintextToken.slice(0, 8)}...${plaintextToken.slice(-6)}`,
     createdAt: now2,
@@ -41353,14 +42030,14 @@ async function assertProfileAccessAllowed(profileManager, profileName) {
 }
 
 // ../../packages/runtime-app-state/src/app/workspaceBindings.ts
-var import_node_fs9 = require("fs");
+var import_node_fs10 = require("fs");
 var import_node_path14 = __toESM(require("path"), 1);
 async function canonicalizeWorkspacePath(input, options = {}) {
   const resolved = import_node_path14.default.resolve(input || process.cwd());
   try {
-    const canonical = await import_node_fs9.promises.realpath(resolved);
+    const canonical = await import_node_fs10.promises.realpath(resolved);
     if (options.requireDirectory !== false) {
-      const stats = await import_node_fs9.promises.stat(canonical);
+      const stats = await import_node_fs10.promises.stat(canonical);
       if (!stats.isDirectory()) {
         throw new Error(`Workspace path is not a directory: ${resolved}`);
       }
@@ -41445,14 +42122,14 @@ async function resolveWorkspaceProfileBinding(requestedPath) {
 
 // src/platform/codexCli.ts
 var import_node_child_process8 = require("child_process");
-var import_node_fs10 = require("fs");
+var import_node_fs11 = require("fs");
 var import_node_path15 = __toESM(require("path"));
 var ENV_HINTS2 = ["CODEX_BINARY", "CODEX_CLI_PATH", "CODEX_PATH"];
 function fileExists2(candidate) {
   if (!candidate) return null;
   const resolved = import_node_path15.default.resolve(candidate);
   try {
-    const stat2 = (0, import_node_fs10.statSync)(resolved);
+    const stat2 = (0, import_node_fs11.statSync)(resolved);
     if (stat2.isFile()) return resolved;
   } catch {
     return null;
@@ -41911,17 +42588,17 @@ async function handleLicense(args2, version) {
 }
 
 // src/commands/profile.ts
-var import_node_fs12 = require("fs");
+var import_node_fs13 = require("fs");
 var import_node_os7 = __toESM(require("os"));
 var import_node_path17 = __toESM(require("path"));
 
 // ../../packages/runtime-app-state/src/app/officialCodexSwitchCoordinator.ts
-var import_node_crypto13 = require("crypto");
-var import_node_fs11 = require("fs");
+var import_node_crypto14 = require("crypto");
+var import_node_fs12 = require("fs");
 var import_node_path16 = __toESM(require("path"), 1);
 var DEFAULT_SWITCH_INTENT_TTL_MS = 10 * 60 * 1e3;
 var SWITCH_INTENT_RENEW_MS = 30 * 1e3;
-var PROCESS_OWNER_ID3 = (0, import_node_crypto13.randomUUID)();
+var PROCESS_OWNER_ID3 = (0, import_node_crypto14.randomUUID)();
 var PROCESS_STARTED_AT3 = readProcessStartedAt(process.pid);
 var localIntentDepth = /* @__PURE__ */ new Map();
 var pendingLocalIntentAcquisitions = /* @__PURE__ */ new Map();
@@ -41931,7 +42608,7 @@ function nextSwitchIntentGeneration(current) {
 }
 async function acquireOfficialCodexSwitchIntent(input) {
   const now2 = Date.now();
-  const operationId = input.operationId?.trim() || (0, import_node_crypto13.randomUUID)();
+  const operationId = input.operationId?.trim() || (0, import_node_crypto14.randomUUID)();
   const targetProfileName = input.targetProfileName.trim();
   if (!targetProfileName) {
     throw new Error("Profile name is required");
@@ -42425,7 +43102,7 @@ function formatProfileLabel(name, displayName) {
 }
 var AUTO_ROLL_ACCESS_REQUIRED_MESSAGE = "Auto-roll requires a Pro license or an active trial.";
 async function withIsolatedCodexLogin(mode, action) {
-  const home = await import_node_fs12.promises.mkdtemp(import_node_path17.default.join(import_node_os7.default.tmpdir(), "codexuse-cli-login-"));
+  const home = await import_node_fs13.promises.mkdtemp(import_node_path17.default.join(import_node_os7.default.tmpdir(), "codexuse-cli-login-"));
   try {
     await runCodexLogin(mode, {
       HOME: home,
@@ -42435,7 +43112,7 @@ async function withIsolatedCodexLogin(mode, action) {
     });
     return await action(import_node_path17.default.join(home, "auth.json"));
   } finally {
-    await import_node_fs12.promises.rm(home, { recursive: true, force: true }).catch(() => void 0);
+    await import_node_fs13.promises.rm(home, { recursive: true, force: true }).catch(() => void 0);
   }
 }
 async function assertOfficialCodexProfileStopped(profileName) {
@@ -43953,7 +44630,7 @@ async function pushRemoteSnapshot(access, snapshot2, options) {
 
 // ../../packages/runtime-profiles/src/cloud-sync/encryption.ts
 var import_node_child_process10 = require("child_process");
-var import_node_crypto14 = require("crypto");
+var import_node_crypto15 = require("crypto");
 var KEYCHAIN_SERVICE2 = "CODEXUSE_CLOUD_SYNC_PASSPHRASE";
 var KEYCHAIN_ACCOUNT_PREFIX2 = "license-sha256:";
 var ENCRYPTION_AAD = Buffer.from("codexuse-cloud-sync-v2", "utf8");
@@ -43978,7 +44655,7 @@ function requireCloudSyncPassphrase(value3) {
 }
 async function deriveKey(passphrase, salt, params = SCRYPT_PARAMS) {
   return new Promise((resolve2, reject) => {
-    (0, import_node_crypto14.scrypt)(passphrase, salt, params.keyLength, {
+    (0, import_node_crypto15.scrypt)(passphrase, salt, params.keyLength, {
       N: params.N,
       r: params.r,
       p: params.p,
@@ -44015,10 +44692,10 @@ function normalizeDecryptedSnapshot(value3) {
   };
 }
 async function encryptCloudSyncSnapshot(snapshot2, passphrase) {
-  const salt = (0, import_node_crypto14.randomBytes)(16);
-  const iv = (0, import_node_crypto14.randomBytes)(12);
+  const salt = (0, import_node_crypto15.randomBytes)(16);
+  const iv = (0, import_node_crypto15.randomBytes)(12);
   const key = await deriveKey(requireCloudSyncPassphrase(passphrase), salt);
-  const cipher = (0, import_node_crypto14.createCipheriv)("aes-256-gcm", key, iv);
+  const cipher = (0, import_node_crypto15.createCipheriv)("aes-256-gcm", key, iv);
   cipher.setAAD(ENCRYPTION_AAD);
   const plaintext = Buffer.from(JSON.stringify(snapshot2), "utf8");
   const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
@@ -44045,7 +44722,7 @@ async function decryptCloudSyncSnapshot(snapshot2, passphrase) {
     const tag2 = fromBase64(snapshot2.encryption.tag);
     const ciphertext = fromBase64(snapshot2.encryption.ciphertext);
     const key = await deriveKey(requireCloudSyncPassphrase(passphrase), salt, snapshot2.encryption.kdfParams);
-    const decipher = (0, import_node_crypto14.createDecipheriv)("aes-256-gcm", key, iv);
+    const decipher = (0, import_node_crypto15.createDecipheriv)("aes-256-gcm", key, iv);
     decipher.setAAD(ENCRYPTION_AAD);
     decipher.setAuthTag(tag2);
     const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
@@ -44060,7 +44737,7 @@ async function decryptCloudSyncSnapshot(snapshot2, passphrase) {
   }
 }
 function keychainAccountForLicense(licenseKey) {
-  const digest = (0, import_node_crypto14.createHash)("sha256").update(licenseKey).digest("hex");
+  const digest = (0, import_node_crypto15.createHash)("sha256").update(licenseKey).digest("hex");
   return KEYCHAIN_ACCOUNT_PREFIX2 + digest;
 }
 function runSecurityCommand2(args2) {
@@ -44626,7 +45303,7 @@ async function handleSync(args2, version) {
 }
 
 // src/commands/workspace.ts
-var import_node_fs13 = require("fs");
+var import_node_fs14 = require("fs");
 function printWorkspaceHelp() {
   console.log(`Usage:
   codexuse workspace bind <path> <profile>
@@ -44656,7 +45333,7 @@ async function handleWorkspaceCommand(args2) {
       return;
     }
     for (const binding of bindings) {
-      const pathState = await import_node_fs13.promises.stat(binding.rootPath).then(() => "").catch(() => " (path missing)");
+      const pathState = await import_node_fs14.promises.stat(binding.rootPath).then(() => "").catch(() => " (path missing)");
       const profileState = profiles.has(binding.profileName) ? "" : " (profile missing)";
       console.log(`${binding.rootPath} -> ${binding.profileName}${pathState}${profileState}`);
     }
@@ -44720,7 +45397,7 @@ async function ensureCliStorageReady() {
 }
 
 // src/app/main.ts
-var VERSION = true ? "6.0.1" : "0.0.0";
+var VERSION = true ? "6.0.3" : "0.0.0";
 async function runCli() {
   const args2 = process.argv.slice(2);
   if (args2.length === 0) {