bazilion 0.14.0 → 0.14.2

package/dist/daemon.js

@@ -19122,6 +19122,7 @@ var init_client2 = __esm({
 });
 
 // ../daemon/src/index.ts
+import { writeSync as writeSync2 } from "fs";
 import { serve } from "@hono/node-server";
 
 // ../daemon/src/app.ts
@@ -20964,6 +20965,19 @@ function openDb(path) {
     }
   };
 }
+function openInMemoryDb() {
+  const raw2 = new DatabaseSync(":memory:");
+  applyPragmas(raw2, false);
+  return {
+    raw: wrap(raw2),
+    backupTo(path) {
+      return backup(raw2, path);
+    },
+    close() {
+      raw2.close();
+    }
+  };
+}
 function inTx(db, fn) {
   return db.raw.transaction(fn)();
 }
@@ -20973,30 +20987,101 @@ import { readdirSync as readdirSync2, readFileSync as readFileSync5 } from "fs";
 import { dirname, join as join8 } from "path";
 import { fileURLToPath } from "url";
 var migrationsDir = join8(dirname(fileURLToPath(import.meta.url)), "migrations");
+var schemaMigrationsSql = `
+  CREATE TABLE IF NOT EXISTS schema_migrations (
+    version    TEXT PRIMARY KEY,
+    applied_at INTEGER NOT NULL
+  )
+`;
+var INCOMPATIBLE_DATABASE_MESSAGE = "Bazilion cannot start because this home uses an incompatible alpha database schema. Preserve the entire Bazilion home directory as a filesystem backup first, keeping bazilion.db and auth.json together. Then perform the reset with `bazilion uninstall --yes` (from the repository root of a source checkout: `pnpm tsx apps/cli/src/index.ts uninstall --yes`) and start Bazilion again. Use `--all` only if you also want to remove logs and installed skills.";
+var IncompatibleDatabaseError = class extends Error {
+  constructor() {
+    super(INCOMPATIBLE_DATABASE_MESSAGE);
+    this.name = "IncompatibleDatabaseError";
+  }
+};
+var canonicalSchemaObjects = null;
+function migrationFiles() {
+  return readdirSync2(migrationsDir).filter((file) => file.endsWith(".sql")).sort().map((file) => ({
+    version: file.replace(/\.sql$/, ""),
+    sql: readFileSync5(join8(migrationsDir, file), "utf8")
+  }));
+}
+function normalizeSql(sql) {
+  return sql.replace(/\s+/g, " ").trim();
+}
+function schemaObjects(db) {
+  return db.raw.query(
+    `SELECT type, name, tbl_name, sql
+       FROM sqlite_schema
+       WHERE sql IS NOT NULL AND substr(name, 1, 7) <> 'sqlite_'
+       ORDER BY type, name`
+  ).all();
+}
+function schemaPayload(rows) {
+  return rows.map((row) => [row.type, row.name, row.tbl_name, normalizeSql(row.sql)].join("\0")).join("\n");
+}
+function expectedSchema(files) {
+  if (canonicalSchemaObjects !== null) return canonicalSchemaObjects;
+  const canonical = openInMemoryDb();
+  try {
+    canonical.raw.exec(schemaMigrationsSql);
+    for (const file of files) canonical.raw.exec(file.sql);
+    canonicalSchemaObjects = schemaObjects(canonical);
+    return canonicalSchemaObjects;
+  } finally {
+    canonical.close();
+  }
+}
+function assertMigrationCompatibility(db) {
+  const files = migrationFiles();
+  const expectedVersions = files.map((file) => file.version);
+  let appliedVersions;
+  try {
+    appliedVersions = db.raw.query("SELECT version FROM schema_migrations ORDER BY version").all().map((row) => row.version);
+  } catch {
+    throw new IncompatibleDatabaseError();
+  }
+  const actualObjects = schemaObjects(db);
+  const expectedObjects = expectedSchema(files);
+  if (appliedVersions.length === 0) {
+    const migrationTable = actualObjects.filter(
+      (row) => row.type === "table" && row.name === "schema_migrations"
+    );
+    const expectedMigrationTable = expectedObjects.filter(
+      (row) => row.type === "table" && row.name === "schema_migrations"
+    );
+    if (actualObjects.length !== 1 || migrationTable.length !== 1 || schemaPayload(migrationTable) !== schemaPayload(expectedMigrationTable)) {
+      throw new IncompatibleDatabaseError();
+    }
+    return;
+  }
+  if (appliedVersions.length !== expectedVersions.length || appliedVersions.some((version2, index) => version2 !== expectedVersions[index]) || schemaPayload(actualObjects) !== schemaPayload(expectedObjects)) {
+    throw new IncompatibleDatabaseError();
+  }
+}
 function runMigrations(db) {
-  db.raw.exec(`
-    CREATE TABLE IF NOT EXISTS schema_migrations (
-      version    TEXT PRIMARY KEY,
-      applied_at INTEGER NOT NULL
-    )
-  `);
+  const existingObjects = schemaObjects(db);
+  if (existingObjects.length > 0 && !existingObjects.some((row) => row.type === "table" && row.name === "schema_migrations")) {
+    throw new IncompatibleDatabaseError();
+  }
+  db.raw.exec(schemaMigrationsSql);
+  assertMigrationCompatibility(db);
   const applied = new Set(
     db.raw.query("SELECT version FROM schema_migrations").all().map((r) => r.version)
   );
-  const files = readdirSync2(migrationsDir).filter((f) => f.endsWith(".sql")).sort();
-  for (const file of files) {
-    const version2 = file.replace(/\.sql$/, "");
-    if (applied.has(version2)) continue;
-    const sql = readFileSync5(join8(migrationsDir, file), "utf8");
+  for (const file of migrationFiles()) {
+    if (applied.has(file.version)) continue;
     const tx = db.raw.transaction(() => {
-      db.raw.exec(sql);
+      db.raw.exec(file.sql);
       db.raw.run("INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)", [
-        version2,
+        file.version,
         Date.now()
       ]);
     });
     tx();
   }
+  assertMigrationCompatibility(db);
 }
 
 // ../daemon/src/core/paths.ts
@@ -25150,20 +25235,61 @@ import {
 } from "fs";
 import { dirname as dirname3, isAbsolute, join as join13, relative, resolve as resolve3, sep as sep2 } from "path";
 import { createStore, extractSnippet } from "@tobilu/qmd";
+
+// ../daemon/src/lib/native-module-error.ts
+var NODE_MODULE_ABI_MISMATCH = /was compiled against a different Node\.js version using\s+NODE_MODULE_VERSION\s+(\d+)[\s\S]*?requires\s+NODE_MODULE_VERSION\s+(\d+)/i;
+function formatNativeModuleAbiMismatch(diagnostic, options = {}) {
+  const mismatch = NODE_MODULE_ABI_MISMATCH.exec(diagnostic);
+  if (!mismatch) return void 0;
+  const builtAbi = mismatch[1];
+  const requiredAbi = mismatch[2];
+  const rebuildCommand = /better_sqlite3\.node|better-sqlite3/i.test(diagnostic) ? "`pnpm rebuild better-sqlite3`" : "`pnpm rebuild`";
+  const subject = options.subject ?? "Bazilion";
+  return `${subject} could not load a native dependency built for Node module ABI ${builtAbi}; the current ${process.version} runtime requires ABI ${requiredAbi}. Reinstall Bazilion with this same Node.js version, then restart it. From the repository root of a source checkout, run ${rebuildCommand} (or \`pnpm install --force\`).`;
+}
+var NativeModuleAbiMismatchError = class extends Error {
+  code = "native_module_abi_mismatch";
+  constructor(message) {
+    super(message);
+    this.name = "NativeModuleAbiMismatchError";
+  }
+};
+function sanitizeNativeModuleError(error2, options = {}) {
+  const diagnostic = error2 instanceof Error ? error2.message : String(error2);
+  const formatted = formatNativeModuleAbiMismatch(diagnostic, options);
+  if (!formatted) return error2;
+  return new NativeModuleAbiMismatchError(formatted);
+}
+async function withNativeModuleErrorBoundary(operation, options = {}) {
+  try {
+    return await operation();
+  } catch (error2) {
+    throw sanitizeNativeModuleError(error2, options);
+  }
+}
+
+// ../daemon/src/runtime/memory/qmd.ts
 var INDEX_FILENAME = ".qmd-index.sqlite";
 var COLLECTION_NAME = "memory";
 var PATTERN = "**/*.md";
+var QMD_NATIVE_ERROR_OPTIONS = { subject: "Bazilion memory" };
 var storeCache = /* @__PURE__ */ new Map();
-function getStore(dir) {
+function getStore(dir, storeFactory) {
   let p = storeCache.get(dir);
   if (!p) {
-    p = createStore({
-      dbPath: join13(dir, INDEX_FILENAME),
-      config: {
-        collections: {
-          [COLLECTION_NAME]: { path: dir, pattern: PATTERN }
+    p = withNativeModuleErrorBoundary(
+      () => storeFactory({
+        dbPath: join13(dir, INDEX_FILENAME),
+        config: {
+          collections: {
+            [COLLECTION_NAME]: { path: dir, pattern: PATTERN }
+          }
         }
-      }
+      }),
+      QMD_NATIVE_ERROR_OPTIONS
+    ).catch((error2) => {
+      storeCache.delete(dir);
+      throw error2;
     });
     storeCache.set(dir, p);
   }
@@ -25346,8 +25472,9 @@ function walkMd(root, dir, prefix, out) {
     }
   }
 }
-function qmdBackend(root) {
+function qmdBackend(root, options = {}) {
   let canonicalRoot;
+  const storeFactory = options.createStore ?? createStore;
   const safeRoot = () => {
     if (!canonicalRoot) canonicalRoot = initializeSafeRoot(root);
     else assertRootUnchanged(root, canonicalRoot);
@@ -25357,8 +25484,8 @@ function qmdBackend(root) {
     async init() {
       const safe = safeRoot();
       assertSafeTree(safe);
-      const store = await getStore(safe);
-      await store.update();
+      const store = await getStore(safe, storeFactory);
+      await withNativeModuleErrorBoundary(() => store.update(), QMD_NATIVE_ERROR_OPTIONS);
     },
     async read(key2) {
       const safe = safeRoot();
@@ -25376,19 +25503,22 @@ function qmdBackend(root) {
       const path = safeKey(safe, key2);
       const stats = writeSafeFile(safe, path, content);
       assertSafeTree(safe);
-      const store = await getStore(safe);
-      await store.update();
+      const store = await getStore(safe, storeFactory);
+      await withNativeModuleErrorBoundary(() => store.update(), QMD_NATIVE_ERROR_OPTIONS);
       return { key: key2, content, updatedAt: stats.mtimeMs };
     },
     async search(query, opts) {
       const limit = opts?.limit ?? 10;
       const safe = safeRoot();
       assertSafeTree(safe);
-      const store = await getStore(safe);
-      const results = await store.searchLex(query, {
-        limit,
-        collection: COLLECTION_NAME
-      });
+      const store = await getStore(safe, storeFactory);
+      const results = await withNativeModuleErrorBoundary(
+        () => store.searchLex(query, {
+          limit,
+          collection: COLLECTION_NAME
+        }),
+        QMD_NATIVE_ERROR_OPTIONS
+      );
       const hits = [];
       for (const r of results) {
         const prefix = `${COLLECTION_NAME}/`;
@@ -25423,8 +25553,8 @@ function qmdBackend(root) {
         rmSync10(path);
       }
       assertSafeTree(safe);
-      const store = await getStore(safe);
-      await store.update();
+      const store = await getStore(safe, storeFactory);
+      await withNativeModuleErrorBoundary(() => store.update(), QMD_NATIVE_ERROR_OPTIONS);
     }
   };
 }
@@ -30821,7 +30951,7 @@ async function* spawnWorker(spec, opts) {
     if (!emittedFatal && exit.code !== 0 && exit.code !== null) {
       yield {
         kind: "fatal",
-        error: appendDiagnostic(
+        error: formatWorkerExitFailure(
           `worker exited with code ${exit.code}${exit.signal ? ` (${exit.signal})` : ""}`,
           diagnostic
         )
@@ -30829,7 +30959,7 @@ async function* spawnWorker(spec, opts) {
     } else if (!emittedFatal && exit.signal && exit.code === null) {
       yield {
         kind: "fatal",
-        error: appendDiagnostic(`worker killed by ${exit.signal}`, diagnostic)
+        error: formatWorkerExitFailure(`worker killed by ${exit.signal}`, diagnostic)
       };
     }
   } finally {
@@ -30924,7 +31054,9 @@ function spawnHosts(spec, opts, signal, onBashApproval, onApiKeyRefreshed) {
 }
 function parseFrame(line, accessTokens) {
   try {
-    return redactJsonValue(JSON.parse(line), accessTokens);
+    return normalizeWorkerDiagnosticFrame(
+      redactJsonValue(JSON.parse(line), accessTokens)
+    );
   } catch {
     return {
       kind: "fatal",
@@ -31136,6 +31268,26 @@ async function pumpWorkerStderr(stderr, capture, redactor) {
 function appendDiagnostic(message, diagnostic) {
   return diagnostic ? `${message}: ${diagnostic}` : message;
 }
+function formatWorkerExitFailure(message, diagnostic) {
+  const formatted = formatWorkerDiagnostic(diagnostic);
+  if (formatted !== diagnostic) return formatted;
+  return appendDiagnostic(message, diagnostic);
+}
+function normalizeWorkerDiagnosticFrame(frame) {
+  if (frame.kind === "fatal") {
+    return { ...frame, error: formatWorkerDiagnostic(frame.error) };
+  }
+  if (frame.kind === "event" && frame.event.type === "error") {
+    return {
+      ...frame,
+      event: { ...frame.event, error: formatWorkerDiagnostic(frame.event.error) }
+    };
+  }
+  return frame;
+}
+function formatWorkerDiagnostic(diagnostic) {
+  return formatNativeModuleAbiMismatch(diagnostic, { subject: "worker" }) ?? diagnostic;
+}
 
 // ../daemon/src/lib/api-key.ts
 async function resolveAgentApiKey(db, authToken, agent, opts = {}) {
@@ -35970,8 +36122,20 @@ var _db = null;
 var _paths = null;
 var _authToken = null;
 var _schedulerStarted = false;
+var INCOMPATIBLE_BOOTSTRAP_IDENTITY_MESSAGE = "Bazilion cannot start because auth.json does not match an active bootstrap credential in bazilion.db. Preserve the entire Bazilion home directory as a filesystem backup first, keeping bazilion.db and auth.json together. Then perform the reset with `bazilion uninstall --yes` (from the repository root of a source checkout: `pnpm tsx apps/cli/src/index.ts uninstall --yes`) and start Bazilion again. Use `--all` only if you also want to remove logs and installed skills.";
+var IncompatibleBootstrapIdentityError = class extends Error {
+  constructor() {
+    super(INCOMPATIBLE_BOOTSTRAP_IDENTITY_MESSAGE);
+    this.name = "IncompatibleBootstrapIdentityError";
+  }
+};
 function bootstrap(paths) {
   mkdirSync9(paths.home, { recursive: true });
+  const databaseExists = existsSync17(paths.db);
+  const authFileExists = existsSync17(paths.authFile);
+  if (databaseExists !== authFileExists) {
+    throw new IncompatibleBootstrapIdentityError();
+  }
   for (const d2 of [
     paths.profilesDir,
     paths.agentsDir,
@@ -35982,26 +36146,46 @@ function bootstrap(paths) {
     mkdirSync9(d2, { recursive: true });
   }
   const db = openDb(paths.db);
-  runMigrations(db);
-  const refreshed = refreshDefaultProfileTemplates(paths);
-  if (refreshed.length) {
-    console.log(`bazilion: refreshed default profile templates \u2014 [${refreshed.join(", ")}]`);
-  }
-  if (!existsSync17(paths.authFile)) {
-    const created = webTokens_exports.create(db, "bootstrap", { kind: "bootstrap" });
-    writeFileSync12(paths.authFile, `${JSON.stringify({ token: created.token }, null, 2)}
+  try {
+    runMigrations(db);
+    let existingAuthToken = null;
+    if (authFileExists) {
+      try {
+        existingAuthToken = readAuthFile(paths.authFile).token;
+      } catch {
+        throw new IncompatibleBootstrapIdentityError();
+      }
+      const bootstrap2 = webTokens_exports.findActiveByToken(db, existingAuthToken);
+      if (bootstrap2?.kind !== "bootstrap") {
+        throw new IncompatibleBootstrapIdentityError();
+      }
+    }
+    const refreshed = refreshDefaultProfileTemplates(paths);
+    if (refreshed.length) {
+      console.log(`bazilion: refreshed default profile templates \u2014 [${refreshed.join(", ")}]`);
+    }
+    if (existingAuthToken === null) {
+      const created = webTokens_exports.create(db, "bootstrap", { kind: "bootstrap" });
+      writeFileSync12(paths.authFile, `${JSON.stringify({ token: created.token }, null, 2)}
 `, {
-      mode: 384
-    });
+        mode: 384
+      });
+      try {
+        chmodSync(paths.authFile, 384);
+      } catch {
+      }
+      console.log(`bazilion auto-bootstrapped at ${paths.home}`);
+      console.log(`bootstrap token written to ${paths.authFile}`);
+      return { db, authToken: created.token };
+    }
+    return { db, authToken: existingAuthToken };
+  } catch (error2) {
     try {
-      chmodSync(paths.authFile, 384);
+      db.close();
     } catch {
     }
-    console.log(`bazilion auto-bootstrapped at ${paths.home}`);
-    console.log(`bootstrap token written to ${paths.authFile}`);
-    return { db, authToken: created.token };
+    throw error2;
   }
-  return { db, authToken: readAuthFile(paths.authFile).token };
 }
 function getCtx() {
   if (!_paths) _paths = resolvePaths();
@@ -39947,9 +40131,227 @@ function mutate(c, acknowledged) {
 }
 
 // ../daemon/src/routes/auth-login.ts
-import { spawn as spawn4 } from "child_process";
 import { Hono as Hono4 } from "hono";
 import { deleteCookie, setCookie } from "hono/cookie";
+
+// ../daemon/src/lib/openai-oauth-prompt.ts
+import { spawn as spawn4 } from "child_process";
+import { createServer as createServer2 } from "net";
+var OPENAI_CODEX_CALLBACK_PORT = 1455;
+var WEB_OPENAI_LOGIN_TIMEOUT_MS = 10 * 6e4;
+var DEVICE_CODE_FALLBACK = "`bazilion auth openai login --device-code` (or, from the repository root of a source checkout, `pnpm tsx apps/cli/src/index.ts auth openai login --device-code`)";
+var OpenAICodexCallbackUnavailableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OpenAICodexCallbackUnavailableError";
+  }
+};
+function abortReason(signal) {
+  return signal.reason instanceof Error ? signal.reason : new DOMException("OpenAI browser login cancelled", "AbortError");
+}
+function callbackAddress(host2, port2) {
+  return host2.includes(":") ? `[${host2}]:${port2}` : `${host2}:${port2}`;
+}
+function openAICodexCallbackHost(env = process.env) {
+  return env.PI_OAUTH_CALLBACK_HOST?.trim() || "127.0.0.1";
+}
+function callbackUnavailable(error2, host2, port2) {
+  const code = error2 instanceof Error && "code" in error2 && typeof error2.code === "string" ? error2.code : null;
+  const address = callbackAddress(host2, port2);
+  if (code === "EADDRINUSE") {
+    return new OpenAICodexCallbackUnavailableError(
+      `OpenAI browser login cannot start because callback address ${address} is already in use. Stop the process using that port and try again, or run ${DEVICE_CODE_FALLBACK} in a terminal.`
+    );
+  }
+  return new OpenAICodexCallbackUnavailableError(
+    `OpenAI browser login cannot bind callback address ${address}${code ? ` (${code})` : ""}. Check PI_OAUTH_CALLBACK_HOST and try again, or run ${DEVICE_CODE_FALLBACK} in a terminal.`
+  );
+}
+function closeServer(server3) {
+  if (!server3.listening) return Promise.resolve();
+  return new Promise((resolve8) => server3.close(() => resolve8()));
+}
+async function preflightOpenAICodexCallback(options) {
+  const host2 = options?.host ?? openAICodexCallbackHost();
+  const port2 = options?.port ?? OPENAI_CODEX_CALLBACK_PORT;
+  const server3 = createServer2();
+  try {
+    await new Promise((resolve8, reject2) => {
+      const cleanup = () => {
+        server3.removeListener("error", onError);
+        server3.removeListener("listening", onListening);
+      };
+      const onError = (error2) => {
+        cleanup();
+        reject2(callbackUnavailable(error2, host2, port2));
+      };
+      const onListening = () => {
+        cleanup();
+        resolve8();
+      };
+      server3.once("error", onError);
+      server3.once("listening", onListening);
+      try {
+        server3.listen({ host: host2, port: port2, exclusive: true });
+      } catch (error2) {
+        onError(error2 instanceof Error ? error2 : new Error(String(error2)));
+      }
+    });
+  } finally {
+    await closeServer(server3);
+  }
+}
+function createWebOpenAILoginLifetime(requestSignal, timeoutMs = WEB_OPENAI_LOGIN_TIMEOUT_MS) {
+  const controller = new AbortController();
+  let disposed = false;
+  const abort = (reason) => {
+    if (!disposed && !controller.signal.aborted) controller.abort(reason);
+  };
+  const onRequestAbort = () => {
+    if (requestSignal) abort(abortReason(requestSignal));
+  };
+  if (requestSignal?.aborted) onRequestAbort();
+  else requestSignal?.addEventListener("abort", onRequestAbort, { once: true });
+  const timeout = setTimeout(() => {
+    abort(
+      new DOMException(
+        `OpenAI browser login timed out after 10 minutes. Try again, or run ${DEVICE_CODE_FALLBACK}.`,
+        "TimeoutError"
+      )
+    );
+  }, timeoutMs);
+  timeout.unref();
+  return {
+    signal: controller.signal,
+    abort,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      clearTimeout(timeout);
+      requestSignal?.removeEventListener("abort", onRequestAbort);
+    }
+  };
+}
+function defaultBrowserSpawn(command, args) {
+  return spawn4(command, args, { stdio: "ignore", detached: true });
+}
+function browserLaunchFailure(command, detail3) {
+  return new Error(
+    `Could not open the OpenAI sign-in page with ${command}: ${detail3}. Run ${DEVICE_CODE_FALLBACK} in a terminal.`
+  );
+}
+function launchOpenAICodexBrowser(url2, onFailure, options) {
+  const platform = options?.platform ?? process.platform;
+  const [command, ...args] = platform === "darwin" ? ["open", url2] : platform === "win32" ? ["rundll32.exe", "url.dll,FileProtocolHandler", url2] : ["xdg-open", url2];
+  let failed = false;
+  const fail3 = (error2) => {
+    if (failed) return;
+    failed = true;
+    onFailure(error2);
+  };
+  try {
+    const child = (options?.spawnBrowser ?? defaultBrowserSpawn)(command, args);
+    child.once("error", (error2) => {
+      fail3(browserLaunchFailure(command, error2.message));
+    });
+    child.once("exit", (code, signal) => {
+      if (code === 0) return;
+      const detail3 = code === null ? `terminated by ${signal ?? "an unknown signal"}` : `exited ${code}`;
+      fail3(browserLaunchFailure(command, detail3));
+    });
+    child.unref();
+  } catch (error2) {
+    fail3(
+      browserLaunchFailure(
+        command,
+        error2 instanceof Error ? error2.message : String(error2)
+      )
+    );
+  }
+}
+var webOpenAILoginTail = Promise.resolve();
+function waitForLoginTurn(turn, signal) {
+  if (!signal) return turn;
+  if (signal.aborted) return Promise.reject(abortReason(signal));
+  return new Promise((resolve8, reject2) => {
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      reject2(abortReason(signal));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    void turn.then(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve8();
+    });
+  });
+}
+async function acquireWebOpenAILogin(signal) {
+  const previous = webOpenAILoginTail;
+  let releaseGate = () => {
+  };
+  const gate = new Promise((resolve8) => {
+    releaseGate = resolve8;
+  });
+  webOpenAILoginTail = previous.then(() => gate);
+  try {
+    await waitForLoginTurn(previous, signal);
+  } catch (error2) {
+    void previous.then(releaseGate);
+    throw error2;
+  }
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    releaseGate();
+  };
+}
+function answerWebOpenAIPrompt(prompt, loginSignal) {
+  if (prompt.type === "select") {
+    const browser = prompt.options.find((option) => option.id === "browser");
+    return browser ? Promise.resolve(browser.id) : Promise.reject(new Error("Pi openai-codex provider does not support browser login"));
+  }
+  if (prompt.type !== "manual_code") {
+    return Promise.reject(
+      new Error(
+        "interactive paste not supported in the web flow \u2014 cancel and try again, or use `bazilion auth openai login`"
+      )
+    );
+  }
+  return new Promise((_resolve, reject2) => {
+    const promptSignal = prompt.signal;
+    if (!promptSignal && !loginSignal) return;
+    let settled = false;
+    const cleanup = () => {
+      promptSignal?.removeEventListener("abort", onPromptAbort);
+      loginSignal?.removeEventListener("abort", onLoginAbort);
+    };
+    const cancel3 = (signal) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject2(abortReason(signal));
+    };
+    const onPromptAbort = () => {
+      if (promptSignal) cancel3(promptSignal);
+    };
+    const onLoginAbort = () => {
+      if (loginSignal) cancel3(loginSignal);
+    };
+    if (loginSignal?.aborted) {
+      onLoginAbort();
+      return;
+    }
+    if (promptSignal?.aborted) {
+      onPromptAbort();
+      return;
+    }
+    promptSignal?.addEventListener("abort", onPromptAbort, { once: true });
+    loginSignal?.addEventListener("abort", onLoginAbort, { once: true });
+  });
+}
+
+// ../daemon/src/routes/auth-login.ts
 var authRouter = new Hono4();
 authRouter.get("/auth/whoami", (c) => {
   const { db } = getCtx();
@@ -39988,21 +40390,30 @@ authRouter.delete("/auth/openai", (c) => {
 });
 authRouter.post("/auth/openai/login", async (c) => {
   const { db, authToken } = getCtx();
+  const lifetime = createWebOpenAILoginLifetime(c.req.raw.signal);
+  let releaseLogin;
   try {
+    releaseLogin = await acquireWebOpenAILogin(lifetime.signal);
+    if (lifetime.signal.aborted) throw lifetime.signal.reason;
+    await preflightOpenAICodexCallback();
+    if (lifetime.signal.aborted) throw lifetime.signal.reason;
     const creds = await loginOpenAICodex({
+      signal: lifetime.signal,
       notify: (event2) => {
-        if (event2.type === "auth_url") openBrowser(event2.url);
+        if (event2.type === "auth_url") {
+          launchOpenAICodexBrowser(event2.url, (error2) => lifetime.abort(error2));
+        }
       },
-      prompt: (prompt) => prompt.type === "select" ? Promise.resolve(prompt.options[0]?.id ?? "") : Promise.reject(
-        new Error(
-          "interactive paste not supported in the web flow \u2014 cancel and try again, or use `bazilion auth openai login`"
-        )
-      )
+      prompt: (prompt) => answerWebOpenAIPrompt(prompt, lifetime.signal)
     });
+    if (lifetime.signal.aborted) throw lifetime.signal.reason;
     saveLoginCredentials(db, authToken, creds);
     return c.json(getStatus(db, authToken));
   } catch (err) {
     return c.json({ error: err.message }, 400);
+  } finally {
+    releaseLogin?.();
+    lifetime.dispose();
   }
 });
 authRouter.post("/providers/test", async (c) => {
@@ -40099,17 +40510,6 @@ authRouter.delete("/sessions/:id", (c) => {
   }
   return c.body(null, 204);
 });
-function openBrowser(url2) {
-  const platform = process.platform;
-  const [cmd, ...args] = platform === "darwin" ? ["open", url2] : platform === "win32" ? ["cmd", "/c", "start", '""', url2] : ["xdg-open", url2];
-  try {
-    const child = spawn4(cmd, args, { stdio: "ignore", detached: true });
-    child.unref();
-    child.on("error", () => {
-    });
-  } catch {
-  }
-}
 
 // ../daemon/src/routes/communication.ts
 import { Hono as Hono5 } from "hono";
@@ -40626,6 +41026,7 @@ function readExisting(path) {
         "starting",
         "listening",
         "restoring",
+        "uninstalling",
         "swapping",
         "installed",
         "recovery-required"
@@ -40643,7 +41044,9 @@ function readExisting(path) {
       if (typeof parsed.startedAt === "number" && Number.isFinite(parsed.startedAt)) {
         startedAt = parsed.startedAt;
       }
-      const validOwnerState = owner === "daemon" && state3 !== void 0 && ["starting", "listening"].includes(state3) && (state3 !== "listening" || host2 !== void 0 && port2 !== void 0) || owner === "restore" && state3 !== void 0 && ["restoring", "swapping", "installed", "recovery-required"].includes(state3) && (!["swapping", "recovery-required"].includes(state3) || recoveryPath !== void 0 && hadPrevious !== void 0);
+      const validOwnerState = owner === "daemon" && state3 !== void 0 && ["starting", "listening"].includes(state3) && (state3 !== "listening" || host2 !== void 0 && port2 !== void 0) || owner === "restore" && state3 !== void 0 && ["restoring", "uninstalling", "swapping", "installed", "recovery-required"].includes(
+        state3
+      ) && (!["swapping", "recovery-required"].includes(state3) || recoveryPath !== void 0 && hadPrevious !== void 0);
       if (!validOwnerState) {
         owner = void 0;
         state3 = void 0;
@@ -40737,6 +41140,16 @@ function acquireDaemonLiveness(paths) {
         );
       }
       const livePid = pidIsAlive(existing.pid);
+      if (existing.owner === "restore" && existing.state === "uninstalling") {
+        if (livePid) {
+          throw new Error(
+            `uninstall process ${existing.pid} is modifying this home; wait for it to finish`
+          );
+        }
+        throw new Error(
+          "a previous Bazilion uninstall was interrupted for this home. Re-run the same `bazilion uninstall` command (including its `--all` choice) with the same BAZILION_HOME (or --home) to finish it before starting Bazilion again."
+        );
+      }
       if (existing.owner === "restore" && ["swapping", "recovery-required"].includes(existing.state)) {
         if (livePid) {
           throw new Error(
@@ -42180,20 +42593,30 @@ teamsRouter.put("/:id/topic-format", async (c) => {
   );
   return c.json(teams_exports.get(db, id, paths));
 });
+var TeamMemoryNotFoundError = class extends Error {
+};
 async function openMemory(rawId) {
   const { db, paths } = getCtx();
   const team = teams_exports.get(db, rawId, paths);
-  if (!team) throw new Error(`team not found: ${rawId}`);
+  if (!team) throw new TeamMemoryNotFoundError(`team not found: ${rawId}`);
   const mem = qmdBackend(join29(team.path, "memory"));
   await mem.init();
   return { mem, team };
 }
+function teamMemoryError(c, error2) {
+  const safe = sanitizeNativeModuleError(error2, { subject: "Bazilion memory" });
+  const message = safe instanceof Error ? safe.message : String(safe);
+  if (safe instanceof TeamMemoryNotFoundError || message.startsWith("memory entry not found:")) {
+    return c.json({ error: message }, 404);
+  }
+  return c.json({ error: message }, 500);
+}
 teamsRouter.get("/:id/memory", async (c) => {
   try {
     const { mem } = await openMemory(c.req.param("id"));
     return c.json(await mem.list());
   } catch (err) {
-    return c.json({ error: err.message }, 404);
+    return teamMemoryError(c, err);
   }
 });
 teamsRouter.get("/:id/memory/search", async (c) => {
@@ -42204,7 +42627,7 @@ teamsRouter.get("/:id/memory/search", async (c) => {
     const { mem } = await openMemory(c.req.param("id"));
     return c.json(await mem.search(q2, { limit }));
   } catch (err) {
-    return c.json({ error: err.message }, 404);
+    return teamMemoryError(c, err);
   }
 });
 teamsRouter.get("/:id/memory/:key{.+}", async (c) => {
@@ -42212,7 +42635,7 @@ teamsRouter.get("/:id/memory/:key{.+}", async (c) => {
     const { mem } = await openMemory(c.req.param("id"));
     return c.json(await mem.read(c.req.param("key")));
   } catch (err) {
-    return c.json({ error: err.message }, 404);
+    return teamMemoryError(c, err);
   }
 });
 teamsRouter.put("/:id/memory/:key{.+}", async (c) => {
@@ -42223,7 +42646,7 @@ teamsRouter.put("/:id/memory/:key{.+}", async (c) => {
     const { mem } = await openMemory(c.req.param("id"));
     return c.json(await mem.write(c.req.param("key"), body.content));
   } catch (err) {
-    return c.json({ error: err.message }, 500);
+    return teamMemoryError(c, err);
   }
 });
 teamsRouter.delete("/:id/memory/:key{.+}", async (c) => {
@@ -42232,7 +42655,7 @@ teamsRouter.delete("/:id/memory/:key{.+}", async (c) => {
     await mem.remove(c.req.param("key"));
     return c.body(null, 204);
   } catch (err) {
-    return c.json({ error: err.message }, 500);
+    return teamMemoryError(c, err);
   }
 });
 function teamPolicyError(c, error2) {
@@ -42628,7 +43051,22 @@ try {
   );
   process.exit(1);
 }
-getCtx();
+try {
+  getCtx();
+} catch (error2) {
+  const detail3 = error2 instanceof IncompatibleDatabaseError || error2 instanceof IncompatibleBootstrapIdentityError ? error2.message : error2 instanceof Error ? error2.stack ?? error2.message : String(error2);
+  writeSync2(process.stderr.fd, `bazilion daemon failed to start: ${detail3}
+`);
+  try {
+    closeCtxForShutdown();
+  } catch {
+  }
+  try {
+    daemonLiveness.stop();
+  } catch {
+  }
+  process.exit(1);
+}
 var app = createApp();
 var shuttingDown = false;
 var server2 = serve({ fetch: app.fetch, hostname: host, port }, (info) => {