@cortexkit/opencode-antigravity-auth 3.0.3 → 3.0.4

package/dist/cli.js

@@ -540,16 +540,293 @@ var init_identity = __esm({
   }
 });
 
-// ../core/dist/common-auth-embedded/fs/atomic-write.js
+// ../core/dist/common-auth-embedded/fs/private-files.js
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { mkdir as mkdir6, open as open3, rename as rename3, rm as rm3 } from "node:fs/promises";
-import { dirname as dirname5 } from "node:path";
+import { lstat as lstat2, readFile as readFile4, rename as rename3, unlink as unlink5 } from "node:fs/promises";
+import { dirname as dirname5, resolve as resolve2 } from "node:path";
+function ioCode(detail) {
+  if (detail?.reason === "io-error") {
+    if (detail.win32Code === 2 || detail.win32Code === 3)
+      return "ENOENT";
+    if (detail.win32Code === 80 || detail.win32Code === 183)
+      return "EEXIST";
+  }
+  return detail?.code ?? "ERR_PRIVATE_FILE";
+}
+function loadBackend() {
+  backend ??= import("@cortexkit/private-files");
+  return backend;
+}
+async function privateOperation(path2, stage, operation) {
+  try {
+    return await operation();
+  } catch (cause) {
+    if (cause instanceof PrivateFileError)
+      throw cause;
+    throw new PrivateFileError(path2, stage, cause);
+  }
+}
+async function verifySafeDirectory(path2, options) {
+  path2 = resolve2(path2);
+  options ??= safeParentOptionsForTest;
+  await privateOperation(path2, "safe-parent", async () => {
+    const result = await (await loadBackend()).verifySafeParent(path2, options);
+    if (result.ok === false) {
+      if (result.reason === "io-error" || result.reason === "wrong-kind")
+        await lstat2(path2);
+      throw new PrivateFileError(result.level ?? result.path, "safe-parent", {
+        ...result,
+        code: "ERR_PRIVATE_FILES_SECURITY"
+      });
+    }
+  });
+}
+async function verifyPrivate(path2, kind, migrate = false) {
+  path2 = resolve2(path2);
+  if (kind === "directory")
+    return verifySafeDirectory(path2);
+  await privateOperation(path2, "verify", async () => {
+    const api = await loadBackend();
+    const result = await api.verifyOwnerOnly(path2);
+    let repaired = false;
+    if (!result.ok) {
+      const { reason } = result.refusal;
+      if (reason === "io-error")
+        await api.verifyPrivatePath(path2, kind);
+      if (migrate && [
+        api.EXTRA_ACE,
+        api.NOT_PROTECTED,
+        api.NULL_DACL,
+        api.EMPTY_DACL
+      ].includes(reason)) {
+        await verifySafeDirectory(dirname5(path2));
+        await api.securePrivatePath(path2, kind);
+        repaired = true;
+      } else {
+        throw Object.assign(new Error("Owner-only verification refused"), {
+          reason,
+          code: "ERR_PRIVATE_FILES_SECURITY"
+        });
+      }
+    }
+    await api.verifyPrivatePath(path2, kind);
+    if (repaired && !migrationNotices.has(path2)) {
+      migrationNotices.add(path2);
+      process.emitWarning(`Private permissions tightened: ${path2}. This object may have been readable before; rotate credentials if needed.`, "PrivateFileMigration");
+    }
+  });
+}
+async function ensurePrivateDirectory(path2, _migrate = false, options) {
+  path2 = resolve2(path2);
+  await privateOperation(path2, "directory", async () => {
+    const api = await loadBackend();
+    try {
+      await lstat2(path2);
+      return await verifySafeDirectory(path2, options);
+    } catch (error) {
+      if (ioCode(error) !== "ENOENT")
+        throw error;
+    }
+    const parent = dirname5(path2);
+    if (parent === path2)
+      throw Object.assign(new Error("Missing root"), { code: "ENOENT" });
+    await ensurePrivateDirectory(parent, false, options);
+    try {
+      await api.createOwnerOnly(path2, { kind: "dir" });
+    } catch (error) {
+      if (ioCode(error) !== "EEXIST")
+        throw error;
+    }
+    await verifySafeDirectory(path2, options);
+  });
+}
+async function readPrivateText(path2, migrate = false) {
+  if (!windowsPrivateFiles)
+    return readFile4(path2, "utf8");
+  return (await readPrivateBuffer(path2, migrate)).toString("utf8");
+}
+async function readPrivateBuffer(path2, migrate = false) {
+  if (!windowsPrivateFiles)
+    return readFile4(path2);
+  path2 = resolve2(path2);
+  if (migrate) {
+    await verifySafeDirectory(dirname5(path2));
+    await verifyPrivate(path2, "file", true);
+  }
+  return privateOperation(path2, "read", async () => (await loadBackend()).readOwnerOnly(path2));
+}
+async function createPrivateBytes(path2, bytes) {
+  await verifySafeDirectory(dirname5(resolve2(path2)));
+  await privateOperation(path2, "create", async () => {
+    await (await loadBackend()).createPrivateFile(resolve2(path2), bytes);
+  });
+}
+async function createPrivateDirectoryExclusive(path2) {
+  await verifySafeDirectory(dirname5(resolve2(path2)));
+  await privateOperation(path2, "directory-create", async () => {
+    await (await loadBackend()).createOwnerOnly(resolve2(path2), { kind: "dir" });
+  });
+}
+async function replaceWindowsFile(from, to, options = {}) {
+  from = resolve2(from);
+  to = resolve2(to);
+  const now = options.now ?? (() => performance.now());
+  const start = now();
+  const deadline = Math.min(start + 500, options.deadline ?? Infinity);
+  const delays = [0, 10, 20, 40, 80, 100];
+  let original;
+  let attempts = 0;
+  for (const delay of delays) {
+    if (now() >= deadline)
+      break;
+    if (delay)
+      await (options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms))))(Math.min(delay, Math.max(0, deadline - now())));
+    if (now() >= deadline)
+      break;
+    await options.beforeRename?.();
+    if (now() >= deadline)
+      break;
+    attempts++;
+    try {
+      await (options.rename ?? rename3)(from, to);
+      return { attempts, elapsedMs: now() - start };
+    } catch (error2) {
+      original ??= error2;
+      const detail = error2;
+      const candidate = detail.win32Code !== void 0 ? detail.win32Code === 32 || detail.win32Code === 33 : ["EBUSY", "EPERM", "EACCES"].includes(detail.code ?? "") && !detail.reason;
+      if (!candidate)
+        break;
+    }
+  }
+  const error = new PrivateFileError(to, "rename", original ?? Object.assign(new Error("Publication deadline expired"), {
+    code: "ETIMEDOUT"
+  }));
+  error.attempts = attempts;
+  error.elapsedMs = now() - start;
+  throw error;
+}
+async function writePrivateAtomic(path2, bytes, options = {}) {
+  path2 = resolve2(path2);
+  await ensurePrivateDirectory(dirname5(path2));
+  try {
+    await verifyPrivate(path2, "file", true);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+  const stage = resolve2(options.stagePath ?? `${path2}.${randomUUID5()}.tmp`);
+  if (dirname5(stage) !== dirname5(path2))
+    throw new PrivateFileError(path2, "stage-directory", { code: "EXDEV" });
+  let created = false;
+  let published = false;
+  let outcome = { attempts: 0, elapsedMs: 0 };
+  let stageName = "stage-create";
+  const reportOutcome = (error) => {
+    try {
+      options.onOutcome?.({
+        path: path2,
+        stage: error?.stage ?? "published",
+        published,
+        fileDurable: published,
+        durabilityConfirmed: false,
+        attempts: error?.attempts ?? outcome.attempts,
+        elapsedMs: error?.elapsedMs ?? outcome.elapsedMs,
+        ...error && { code: error.code, win32Code: error.win32Code }
+      });
+    } catch {
+    }
+  };
+  try {
+    await createPrivateBytes(stage, bytes);
+    created = true;
+    stageName = "before-rename";
+    outcome = await replaceWindowsFile(stage, path2, options);
+    created = false;
+    published = true;
+    stageName = "published-callback";
+    options.onRenamed?.();
+    stageName = "published-verify";
+    await verifyPrivate(path2, "file");
+    if (options.durable && options.durability !== "file-only-on-windows")
+      throw new PrivateFileError(path2, "directory-sync-unsupported", {
+        code: "ENOTSUP"
+      });
+    reportOutcome();
+  } catch (cause) {
+    const error = cause instanceof PrivateFileError ? cause : new PrivateFileError(path2, stageName, cause);
+    error.published = published;
+    error.fileDurable = published;
+    if (published)
+      Object.assign(error, outcome);
+    if (created) {
+      try {
+        await unlink5(stage);
+      } catch {
+        error.orphanPath = stage;
+      }
+      created = false;
+    }
+    reportOutcome(error);
+    throw error;
+  } finally {
+    if (created)
+      await unlink5(stage).catch(() => {
+      });
+  }
+}
+var windowsPrivateFiles, migrationNotices, backend, PrivateFileError, safeParentOptionsForTest;
+var init_private_files = __esm({
+  "../core/dist/common-auth-embedded/fs/private-files.js"() {
+    "use strict";
+    windowsPrivateFiles = process.platform === "win32";
+    migrationNotices = /* @__PURE__ */ new Set();
+    PrivateFileError = class extends Error {
+      path;
+      stage;
+      code;
+      win32Code;
+      reason;
+      published = false;
+      durabilityConfirmed = false;
+      fileDurable = false;
+      attempts = 0;
+      elapsedMs = 0;
+      orphanPath;
+      constructor(path2, stage, cause) {
+        const detail = cause;
+        super(`Private file refused at ${stage}: ${path2} (${detail?.reason ?? detail?.code ?? "io-error"}). Use a safe parent directory. Repair only a named secret file in safe ancestry whose owner the published policy trusts, without changing its owner or any existing directory. Previously exposed credentials may need rotation. Windows requires the private-files native prebuild and an ACL-persisting local filesystem such as NTFS.`, { cause });
+        this.path = path2;
+        this.stage = stage;
+        this.name = "PrivateFileError";
+        this.code = ioCode(detail);
+        this.win32Code = detail?.win32Code;
+        this.reason = detail?.reason;
+      }
+    };
+  }
+});
+
+// ../core/dist/common-auth-embedded/fs/atomic-write.js
+import { randomUUID as randomUUID6 } from "node:crypto";
+import { mkdir as mkdir6, open as open3, rename as rename4, rm as rm3 } from "node:fs/promises";
+import { dirname as dirname6 } from "node:path";
 async function writeJsonAtomic2(path2, value, options = {}) {
   await writeJsonAtomicTracked(path2, value, options);
 }
 async function writeJsonAtomicTracked(path2, value, options, onRenamed) {
-  await mkdir6(dirname5(path2), { recursive: true });
-  const tempPath = `${path2}.${(options.stageName ?? randomUUID5)()}.tmp`;
+  if (windowsPrivateFiles) {
+    return writePrivateAtomic(path2, options.serialize ? options.serialize(value) : `${JSON.stringify(value, null, 2)}
+`, {
+      beforeRename: options.beforeRename,
+      stagePath: `${path2}.${(options.stageName ?? randomUUID6)()}.tmp`,
+      onRenamed,
+      durable: options.durable,
+      durability: options.durability,
+      onOutcome: options.onOutcome
+    });
+  }
+  await mkdir6(dirname6(path2), { recursive: true });
+  const tempPath = `${path2}.${(options.stageName ?? randomUUID6)()}.tmp`;
   let handle;
   let created = false;
   try {
@@ -568,11 +845,11 @@ async function writeJsonAtomicTracked(path2, value, options, onRenamed) {
     await handle.close();
     handle = void 0;
     await options.beforeRename?.();
-    await rename3(tempPath, path2);
+    await rename4(tempPath, path2);
     created = false;
     onRenamed?.();
     if (options.durable) {
-      const directory = await open3(dirname5(path2), "r");
+      const directory = await open3(dirname6(path2), "r");
       try {
         await directory.sync();
       } catch (cause) {
@@ -590,13 +867,21 @@ async function writeJsonAtomicTracked(path2, value, options, onRenamed) {
   }
 }
 async function syncJsonFile(path2) {
+  if (windowsPrivateFiles) {
+    await verifyPrivate(path2, "file");
+    const error = new PrivateFileError(path2, "directory-sync-unsupported", {
+      code: "ENOTSUP"
+    });
+    error.published = true;
+    throw error;
+  }
   const file = await open3(path2, "r");
   try {
     await file.sync();
   } finally {
     await file.close();
   }
-  const directory = await open3(dirname5(path2), "r");
+  const directory = await open3(dirname6(path2), "r");
   try {
     await directory.sync();
   } finally {
@@ -607,6 +892,7 @@ var AtomicSyncError;
 var init_atomic_write = __esm({
   "../core/dist/common-auth-embedded/fs/atomic-write.js"() {
     "use strict";
+    init_private_files();
     AtomicSyncError = class extends Error {
       constructor(cause) {
         super("file or directory sync failed", { cause });
@@ -617,24 +903,25 @@ var init_atomic_write = __esm({
 });
 
 // ../core/dist/common-auth-embedded/fs/refresh-file-lock.js
-import { randomUUID as randomUUID6 } from "node:crypto";
-import { mkdir as mkdir7, open as open4, readFile as readFile4, rename as rename4, rm as rm4, stat as stat3, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname6, join as join4 } from "node:path";
+import { randomUUID as randomUUID7 } from "node:crypto";
+import { mkdir as mkdir7, open as open4, readFile as readFile5, rename as rename5, rm as rm4, stat as stat3, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname7, join as join4 } from "node:path";
 function isLostMarkerRaceError(error) {
   const code2 = error?.code;
-  return code2 === "ENOENT" || code2 === "EINVAL" || code2 === "ENOTDIR";
+  return code2 === "ENOENT" || !windowsPrivateFiles && (code2 === "EINVAL" || code2 === "ENOTDIR");
 }
 async function acquireRefreshFileLock(options) {
   const lockPath = lockPathFor(options.path, options.name);
   const legacyOwnerPath = join4(lockPath, "owner.json");
-  const ownerId = randomUUID6();
+  const ownerId = randomUUID7();
   const now = options.now ?? Date.now;
   let renewTimer = null;
   let released = false;
+  let releaseConfirmed = false;
   let loss;
   let resolveLoss;
-  const lostPromise = new Promise((resolve7) => {
-    resolveLoss = resolve7;
+  const lostPromise = new Promise((resolve13) => {
+    resolveLoss = resolve13;
   });
   function notifyTimerStep(event) {
     try {
@@ -665,24 +952,53 @@ async function acquireRefreshFileLock(options) {
     cancelRenewalTimer();
     resolveLoss(loss);
   }
+  let terminalIOError;
   let renewalInFlight = null;
   const evictPath = `${lockPath}.evicting`;
   const evictOwnerPath = join4(evictPath, "owner.json");
-  const evictOwnerId = randomUUID6();
+  const evictOwnerId = randomUUID7();
   const EVICT_TTL = 5e3;
   const MAX_STEAL_ATTEMPTS = 8;
   async function readOwner() {
+    if (windowsPrivateFiles) {
+      try {
+        return JSON.parse(await readPrivateText(lockPath, true));
+      } catch (error) {
+        if (error.code !== "EISDIR" && error.reason !== "wrong-kind")
+          throw error;
+        await verifyPrivate(lockPath, "directory", true);
+        return JSON.parse(await readPrivateText(legacyOwnerPath, true));
+      }
+    }
     try {
-      return JSON.parse(await readFile4(lockPath, "utf8"));
+      return JSON.parse(await readFile5(lockPath, "utf8"));
     } catch (error) {
       const code2 = error.code;
       if (code2 !== "EISDIR")
         throw error;
-      return JSON.parse(await readFile4(legacyOwnerPath, "utf8"));
+      return JSON.parse(await readFile5(legacyOwnerPath, "utf8"));
     }
   }
   async function writeOwner() {
-    const tempPath = `${lockPath}.${randomUUID6()}.tmp`;
+    if (windowsPrivateFiles) {
+      const owner = await readOwner();
+      const remaining = Number(owner?.expiresAt) - now();
+      await writePrivateAtomic(lockPath, `${JSON.stringify({ ownerId, expiresAt: now() + options.ttlMs })}
+`, {
+        deadline: performance.now() + Math.max(0, remaining),
+        beforeRename: async () => {
+          const current = await readOwner();
+          if (current?.ownerId !== ownerId || !(Number(current?.expiresAt) > now()) || !await ownsEvictionMarker()) {
+            throw new LockOwnershipError({
+              target: options.path,
+              name: options.name
+            });
+          }
+        }
+      });
+      return;
+    }
+    const tempPath = `${lockPath}.${randomUUID7()}.tmp`;
     let handle;
     let created = false;
     try {
@@ -693,7 +1009,14 @@ async function acquireRefreshFileLock(options) {
       await handle.chmod(384);
       await handle.close();
       handle = void 0;
-      await rename4(tempPath, lockPath);
+      const current = await readOwner();
+      if (current?.ownerId !== ownerId || !(Number(current?.expiresAt) > now()) || !await ownsEvictionMarker()) {
+        throw new LockOwnershipError({
+          target: options.path,
+          name: options.name
+        });
+      }
+      await rename5(tempPath, lockPath);
       created = false;
     } finally {
       await handle?.close().catch(() => {
@@ -703,24 +1026,54 @@ async function acquireRefreshFileLock(options) {
         });
     }
   }
+  async function createLease() {
+    const bytes = `${JSON.stringify({ ownerId, expiresAt: now() + options.ttlMs })}
+`;
+    if (windowsPrivateFiles)
+      await createPrivateBytes(lockPath, bytes);
+    else
+      await writeFile3(lockPath, bytes, {
+        encoding: "utf8",
+        mode: 384,
+        flag: "wx"
+      });
+  }
+  async function leaseContention(error) {
+    const code2 = error.code;
+    if (code2 === "EEXIST") {
+      if (windowsPrivateFiles)
+        await readOwner();
+      return true;
+    }
+    if (code2 === "EISDIR") {
+      if (windowsPrivateFiles) {
+        await verifyPrivate(lockPath, "directory", true);
+        await readPrivateText(legacyOwnerPath, true);
+      }
+      return true;
+    }
+    return false;
+  }
   async function tryAcquire() {
+    if (windowsPrivateFiles)
+      await ensurePrivateDirectory(dirname7(lockPath));
     try {
-      await writeFile3(lockPath, `${JSON.stringify({ ownerId, expiresAt: now() + options.ttlMs })}
-`, { encoding: "utf8", mode: 384, flag: "wx" });
+      await createLease();
       return true;
     } catch (error) {
       const code2 = error.code;
-      if (code2 === "EEXIST" || code2 === "EISDIR")
+      if (await leaseContention(error))
         return false;
       if (code2 === "ENOENT") {
-        await mkdir7(dirname6(lockPath), { recursive: true });
+        if (windowsPrivateFiles)
+          await ensurePrivateDirectory(dirname7(lockPath));
+        else
+          await mkdir7(dirname7(lockPath), { recursive: true });
         try {
-          await writeFile3(lockPath, `${JSON.stringify({ ownerId, expiresAt: now() + options.ttlMs })}
-`, { encoding: "utf8", mode: 384, flag: "wx" });
+          await createLease();
           return true;
         } catch (retryError) {
-          const retryCode = retryError.code;
-          if (retryCode === "EEXIST" || retryCode === "EISDIR")
+          if (await leaseContention(retryError))
             return false;
           throw retryError;
         }
@@ -729,40 +1082,98 @@ async function acquireRefreshFileLock(options) {
     }
   }
   async function backoff() {
-    await new Promise((resolve7) => setTimeout(resolve7, Math.floor(Math.random() * 4)));
+    await new Promise((resolve13) => setTimeout(resolve13, Math.floor(Math.random() * 4)));
   }
-  async function lockIsLive() {
+  async function readLockState(notifyReady = true) {
+    if (notifyReady && options.onStep)
+      await options.onStep("lock-read-ready");
+    let owner;
     try {
-      const currentOwner = await readOwner();
-      return Number(currentOwner?.expiresAt) > now();
-    } catch {
-      try {
-        const current = await stat3(lockPath);
-        return current.mtimeMs + options.ttlMs > now();
-      } catch {
-        return false;
+      owner = await readOwner();
+    } catch (error) {
+      if (windowsPrivateFiles && error.code !== "ENOENT")
+        throw error;
+    }
+    const expiresAt = Number(owner?.expiresAt);
+    if (Number.isFinite(expiresAt) && expiresAt > now())
+      return { status: "live" };
+    if (typeof owner?.ownerId === "string" && Number.isFinite(expiresAt)) {
+      return {
+        status: "stale",
+        identity: { kind: "owner", ownerId: owner.ownerId, expiresAt }
+      };
+    }
+    try {
+      const current = await stat3(lockPath);
+      const legacyExpiry = Number.isFinite(expiresAt) ? expiresAt : current.mtimeMs + options.ttlMs;
+      if (legacyExpiry > now())
+        return { status: "live" };
+      return {
+        status: "stale",
+        identity: {
+          kind: "stat",
+          dev: current.dev,
+          ino: current.ino,
+          mtimeMs: current.mtimeMs,
+          expiresAt: legacyExpiry
+        }
+      };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        if (options.onStep)
+          await options.onStep("lock-missing");
+        return { status: "missing" };
       }
+      throw error;
+    }
+  }
+  function sameStaleLock(observed, current) {
+    if (current.status !== "stale")
+      return false;
+    const identity = current.identity;
+    if (observed.kind === "owner" && identity.kind === "owner") {
+      return observed.ownerId === identity.ownerId && observed.expiresAt === identity.expiresAt;
     }
+    return observed.kind === "stat" && identity.kind === "stat" && observed.dev === identity.dev && observed.ino === identity.ino && observed.mtimeMs === identity.mtimeMs && observed.expiresAt === identity.expiresAt;
   }
   async function ownsEvictionMarker() {
     try {
-      const owner = JSON.parse(await readFile4(evictOwnerPath, "utf8"));
+      const owner = JSON.parse(await readPrivateText(evictOwnerPath, windowsPrivateFiles));
       return owner?.ownerId === evictOwnerId;
-    } catch {
+    } catch (error) {
+      if (windowsPrivateFiles && error.code !== "ENOENT")
+        throw error;
       return false;
     }
   }
+  async function removeLeaseObject(path2) {
+    if (windowsPrivateFiles)
+      await privateOperation(path2, "remove", () => rm4(path2, { recursive: true, force: true }));
+    else
+      await rm4(path2, { recursive: true, force: true }).catch(() => {
+      });
+  }
   async function releaseEvictionMarker() {
     if (await ownsEvictionMarker()) {
-      await rm4(evictPath, { recursive: true, force: true }).catch(() => {
-      });
+      await removeLeaseObject(evictPath);
     }
   }
   async function tryAcquireEvictionMarker() {
-    await mkdir7(evictPath);
+    if (windowsPrivateFiles)
+      await createPrivateDirectoryExclusive(evictPath);
+    else
+      await mkdir7(evictPath);
     try {
-      await writeFile3(evictOwnerPath, `${JSON.stringify({ ownerId: evictOwnerId, createdAt: now() })}
-`, { encoding: "utf8", mode: 384, flag: "wx" });
+      const bytes = `${JSON.stringify({ ownerId: evictOwnerId, createdAt: now() })}
+`;
+      if (windowsPrivateFiles)
+        await createPrivateBytes(evictOwnerPath, bytes);
+      else
+        await writeFile3(evictOwnerPath, bytes, {
+          encoding: "utf8",
+          mode: 384,
+          flag: "wx"
+        });
     } catch (error) {
       if (isLostMarkerRaceError(error))
         return false;
@@ -782,13 +1193,15 @@ async function acquireRefreshFileLock(options) {
         return "missing";
       throw error;
     }
+    if (windowsPrivateFiles)
+      await verifyPrivate(evictPath, "directory", true);
     if (evictStat.mtimeMs + EVICT_TTL > now())
       return "fresh";
     if (options.onStep)
       await options.onStep("stale-marker-stat");
-    const claimedPath = `${evictPath}.${randomUUID6()}`;
+    const claimedPath = `${evictPath}.${randomUUID7()}`;
     try {
-      await rename4(evictPath, claimedPath);
+      await rename5(evictPath, claimedPath);
     } catch (error) {
       if (error.code === "ENOENT")
         return "missing";
@@ -796,8 +1209,7 @@ async function acquireRefreshFileLock(options) {
     }
     if (options.onStep)
       await options.onStep("stale-marker-claimed");
-    await rm4(claimedPath, { recursive: true, force: true }).catch(() => {
-    });
+    await removeLeaseObject(claimedPath);
     return "recovered";
   }
   async function withEvictionMarker(action) {
@@ -805,8 +1217,18 @@ async function acquireRefreshFileLock(options) {
       if (!await tryAcquireEvictionMarker())
         return false;
     } catch (error) {
-      if (error.code === "EEXIST")
+      if (error.code === "EEXIST") {
+        if (windowsPrivateFiles) {
+          await verifyPrivate(evictPath, "directory", true);
+          try {
+            await readPrivateText(evictOwnerPath, true);
+          } catch (ownerError) {
+            if (ownerError.code !== "ENOENT")
+              throw ownerError;
+          }
+        }
         return false;
+      }
       throw error;
     }
     try {
@@ -823,7 +1245,9 @@ async function acquireRefreshFileLock(options) {
       let owner;
       try {
         owner = await readOwner();
-      } catch {
+      } catch (error) {
+        if (windowsPrivateFiles)
+          throw error;
         return;
       }
       if (owner?.ownerId !== ownerId)
@@ -831,7 +1255,9 @@ async function acquireRefreshFileLock(options) {
       try {
         await rm4(lockPath, { recursive: true, force: true });
         return;
-      } catch {
+      } catch (error) {
+        if (windowsPrivateFiles)
+          throw error;
         await backoff();
       }
     }
@@ -885,6 +1311,8 @@ async function acquireRefreshFileLock(options) {
               return;
             }
             await writeOwner();
+            if (options.onStep)
+              await options.onStep("renewal-write-finished");
             if (!await ownsEvictionMarker()) {
               recordLoss("marker-lost");
               shouldReschedule = false;
@@ -895,7 +1323,12 @@ async function acquireRefreshFileLock(options) {
           if (!markerAcquired && options.onStep) {
             await options.onStep("renewal-marker-unavailable");
           }
-        } catch {
+        } catch (error) {
+          if (windowsPrivateFiles && error instanceof PrivateFileError) {
+            terminalIOError = error;
+            recordLoss("renewal-failed");
+            shouldReschedule = false;
+          }
           try {
             const owner = await readOwner();
             if (owner?.ownerId !== ownerId)
@@ -943,8 +1376,11 @@ async function acquireRefreshFileLock(options) {
       acquired = await tryAcquire();
       if (acquired)
         break;
-      if (await lockIsLive())
+      const observed = await readLockState();
+      if (observed.status === "live")
         return contended();
+      if (observed.status === "missing")
+        continue;
       if (options.onStep)
         await options.onStep("stale-lock-observed");
       try {
@@ -963,16 +1399,21 @@ async function acquireRefreshFileLock(options) {
         continue;
       }
       try {
-        if (await lockIsLive())
+        const confirmed = await readLockState();
+        if (confirmed.status === "live")
           return contended();
+        if (!sameStaleLock(observed.identity, confirmed))
+          continue;
         if (!await ownsEvictionMarker())
           return null;
         if (options.onStep)
           await options.onStep("stale-lock-confirmed");
         if (!await ownsEvictionMarker())
           return null;
-        await rm4(lockPath, { recursive: true, force: true }).catch(() => {
-        });
+        const current = await readLockState(false);
+        if (!sameStaleLock(observed.identity, current))
+          continue;
+        await removeLeaseObject(lockPath);
         if (!await ownsEvictionMarker())
           return null;
         if (options.onStep)
@@ -1001,6 +1442,8 @@ async function acquireRefreshFileLock(options) {
     whenLost: () => lostPromise,
     hasLost: () => loss !== void 0,
     assertOwned: async () => {
+      if (terminalIOError)
+        throw terminalIOError;
       let observed;
       try {
         const owner = await readOwner();
@@ -1008,8 +1451,10 @@ async function acquireRefreshFileLock(options) {
         if (!released && !loss && owner?.ownerId === ownerId && Number(owner?.expiresAt) > now())
           return;
         recordLoss(owner?.ownerId !== ownerId ? "taken-over" : "expired", owner);
-      } catch {
+      } catch (error) {
         recordLoss("unreadable");
+        if (windowsPrivateFiles && error instanceof PrivateFileError)
+          throw error;
       }
       throw new LockOwnershipError({
         target: options.path,
@@ -1020,30 +1465,56 @@ async function acquireRefreshFileLock(options) {
       });
     },
     release: async () => {
+      if (windowsPrivateFiles && releaseConfirmed)
+        return;
       released = true;
       cancelRenewalTimer();
       await renewalInFlight;
       for (let attempt = 0; attempt < MAX_STEAL_ATTEMPTS; attempt++) {
         try {
+          let removalConfirmed = false;
           const markerAcquired = await withEvictionMarker(async () => {
-            const owner = await readOwner();
-            if (owner?.ownerId !== ownerId)
+            let owner;
+            try {
+              owner = await readOwner();
+            } catch (error) {
+              if (windowsPrivateFiles && error.code === "ENOENT") {
+                removalConfirmed = true;
+                return;
+              }
+              throw error;
+            }
+            if (owner?.ownerId !== ownerId) {
+              removalConfirmed = true;
               return;
+            }
             if (options.onStep)
               await options.onStep("release-owner-confirmed");
             if (!await ownsEvictionMarker())
               return;
-            await rm4(lockPath, { recursive: true, force: true }).catch(() => {
-            });
+            await removeLeaseObject(lockPath);
+            removalConfirmed = true;
           });
-          if (markerAcquired)
+          if (markerAcquired) {
+            if (windowsPrivateFiles && !removalConfirmed)
+              throw new PrivateFileError(lockPath, "release-not-confirmed", {
+                code: "EIO"
+              });
+            releaseConfirmed = removalConfirmed;
             return;
+          }
           await recoverStaleEvictionMarker();
-        } catch {
+        } catch (error) {
+          if (windowsPrivateFiles)
+            throw error;
           return;
         }
         await backoff();
       }
+      if (windowsPrivateFiles)
+        throw new PrivateFileError(lockPath, "release-not-confirmed", {
+          code: "ETIMEDOUT"
+        });
     }
   };
 }
@@ -1051,6 +1522,7 @@ var setRefreshLockRenewalTimeout, clearRefreshLockRenewalTimeout;
 var init_refresh_file_lock = __esm({
   "../core/dist/common-auth-embedded/fs/refresh-file-lock.js"() {
     "use strict";
+    init_private_files();
     init_with_lock();
     setRefreshLockRenewalTimeout = globalThis.setTimeout.bind(globalThis);
     clearRefreshLockRenewalTimeout = globalThis.clearTimeout.bind(globalThis);
@@ -1068,7 +1540,9 @@ async function withLock(target, options, fn) {
       path: target,
       name: options.name,
       ttlMs: options.ttlMs,
-      renew: options.renew ?? false
+      renew: options.renew ?? false,
+      ...options.onStep ? { onStep: options.onStep } : {},
+      ...options.onRenewalTimer ? { onRenewalTimer: options.onRenewalTimer } : {}
     });
     if (lock) {
       try {
@@ -1085,7 +1559,7 @@ async function withLock(target, options, fn) {
         timeoutMs: options.timeoutMs
       });
     }
-    await new Promise((resolve7) => setTimeout(resolve7, Math.min(25, Math.ceil(remaining))));
+    await new Promise((resolve13) => setTimeout(resolve13, Math.min(25, Math.ceil(remaining))));
   }
 }
 var LockContentionError, LockOwnershipError;
@@ -1169,6 +1643,9 @@ async function acquirePoolLock(spec, defaults, env3) {
       now: env3.now,
       renew: options.renew,
       onContended: () => emit("contended"),
+      ...env3.onRenewalTimer ? {
+        onRenewalTimer: (event) => env3.onRenewalTimer?.({ name: spec.name, path: spec.path }, event)
+      } : {},
       ...options.renewIntervalMs !== void 0 ? { renewIntervalMs: options.renewIntervalMs } : {},
       ...env3.onLockStep ? {
         onStep: (step) => env3.onLockStep?.({ name: spec.name, path: spec.path }, step)
@@ -1202,7 +1679,7 @@ async function acquirePoolLock(spec, defaults, env3) {
       });
     }
     const jitter = Math.floor(Math.random() * (options.retryMs + 1));
-    await new Promise((resolve7) => setTimeout(resolve7, Math.min(options.retryMs + jitter, remaining)));
+    await new Promise((resolve13) => setTimeout(resolve13, Math.min(options.retryMs + jitter, remaining)));
   }
 }
 function definedOnly(spec) {
@@ -1961,11 +2438,10 @@ var init_torn = __esm({
 });
 
 // ../core/dist/common-auth-embedded/store/mutate.js
-import { readFile as readFile5 } from "node:fs/promises";
 import { setTimeout as snapshotDelay } from "node:timers/promises";
 async function readText(path2) {
   try {
-    return await readFile5(path2, "utf8");
+    return await readPrivateText(path2, windowsPrivateFiles);
   } catch (error) {
     if (error.code === "ENOENT")
       return void 0;
@@ -2173,6 +2649,7 @@ var init_mutate = __esm({
   "../core/dist/common-auth-embedded/store/mutate.js"() {
     "use strict";
     init_atomic_write();
+    init_private_files();
     init_with_lock();
     init_errors();
     init_hooks();
@@ -2665,7 +3142,7 @@ var init_provider_state = __esm({
 });
 
 // ../core/dist/common-auth-embedded/store/rows.js
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 async function protectIn(tx, id, protect) {
   if (!protect)
     return;
@@ -3300,7 +3777,7 @@ async function transitionRow(rt, operation, id, flag, options) {
         await tx.commitState();
         return result;
       }
-      const transition = flag.enabled ? { mark: randomUUID7(), enabled: true } : { mark: randomUUID7(), enabled: false, reason: flag.reason };
+      const transition = flag.enabled ? { mark: randomUUID8(), enabled: true } : { mark: randomUUID8(), enabled: false, reason: flag.reason };
       const stamp = plan.account[CREDENTIAL_STAMP_KEY];
       tx.setStateAccount(id, {
         ...plan.account,
@@ -3937,7 +4414,7 @@ var init_pull = __esm({
 });
 
 // ../core/dist/common-auth-embedded/store/refresh.js
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 function requireRefreshable(id, row) {
   assertNotReserved("refresh", id, row?.staged);
   if (!row)
@@ -4054,7 +4531,7 @@ async function refreshRow(rt, id, provider, options = {}) {
         returnedIdentity: result.identity
       } : void 0;
       const transition = contradiction ? {
-        mark: randomUUID8(),
+        mark: randomUUID9(),
         enabled: false,
         reason: `${IDENTITY_CONTRADICTED_REASON_PREFIX}${JSON.stringify(contradiction)}`
       } : void 0;
@@ -4280,7 +4757,8 @@ function openPoolStore(options) {
     lockEnv: {
       now: options.now ?? Date.now,
       ...options.onLockEvent ? { onLockEvent: options.onLockEvent } : {},
-      ...options.onLockStep ? { onLockStep: options.onLockStep } : {}
+      ...options.onLockStep ? { onLockStep: options.onLockStep } : {},
+      ...options.onRenewalTimer ? { onRenewalTimer: options.onRenewalTimer } : {}
     },
     removedIds: memory.removedIds,
     requireCredentialStamps: options.requireCredentialStamps === true,
@@ -4412,6 +4890,7 @@ var fs_exports = {};
 __export(fs_exports, {
   LockContentionError: () => LockContentionError,
   LockOwnershipError: () => LockOwnershipError,
+  PrivateFileError: () => PrivateFileError,
   WRITER_LOCK_CONSTANTS: () => WRITER_LOCK_CONSTANTS,
   acquireRefreshFileLock: () => acquireRefreshFileLock,
   isLostMarkerRaceError: () => isLostMarkerRaceError,
@@ -4424,6 +4903,7 @@ var init_fs = __esm({
     "use strict";
     init_atomic_write();
     init_lock_constants();
+    init_private_files();
     init_refresh_file_lock();
     init_with_lock();
   }
@@ -4496,7 +4976,7 @@ function admit(input) {
   const scope = input.scope ?? ALL_SCOPE;
   const requiredLabels = input.requiredLabels ?? DEFAULT_REQUIRED_LABELS;
   const excluded = [];
-  const refused = [];
+  const refused2 = [];
   const survivors = [];
   for (const row of input.rows) {
     const exclusion = exclusionFor(row.id, input, input.now);
@@ -4509,9 +4989,9 @@ function admit(input) {
       continue;
     }
     const projection = projectQuota(row.quota, scope);
-    const refusal3 = judgeStageOne(row.id, projection, requiredLabels, input.now);
-    if (refusal3) {
-      refused.push(refusal3);
+    const refusal4 = judgeStageOne(row.id, projection, requiredLabels, input.now);
+    if (refusal4) {
+      refused2.push(refusal4);
       continue;
     }
     survivors.push({ id: row.id, kind: row.kind, projection });
@@ -4529,16 +5009,16 @@ function admit(input) {
     } else if (lastPath) {
       admitted.push({ ...row, lastPath: true });
     } else {
-      refused.push({ id: row.id, stage: 2, reason: "budget-spent", ...reset });
+      refused2.push({ id: row.id, stage: 2, reason: "budget-spent", ...reset });
     }
   }
   const order = new Map(input.rows.map((row, index) => [row.id, index]));
   const byInput = (left, right) => (order.get(left.id) ?? 0) - (order.get(right.id) ?? 0);
-  refused.sort(byInput);
-  const pulls = refused.filter((refusal3) => "pullRequested" in refusal3).map((refusal3) => refusal3.id);
+  refused2.sort(byInput);
+  const pulls = refused2.filter((refusal4) => "pullRequested" in refusal4).map((refusal4) => refusal4.id);
   for (const id of pulls)
     input.requestPull?.(id);
-  return { admitted, refused, excluded, pulls };
+  return { admitted, refused: refused2, excluded, pulls };
 }
 var init_admission = __esm({
   "../core/dist/common-auth-embedded/routing/admission.js"() {
@@ -4809,9 +5289,9 @@ function routeSticky(input) {
     });
     if (!selection)
       break;
-    const refusal3 = refusals.get(selection.accountId);
-    if (refusal3) {
-      refusedSelections.push(refusal3);
+    const refusal4 = refusals.get(selection.accountId);
+    if (refusal4) {
+      refusedSelections.push(refusal4);
       candidates = candidates.filter((candidate) => candidate.accountId !== selection.accountId);
       continue;
     }
@@ -4888,15 +5368,15 @@ var init_routing = __esm({
 
 // ../core/dist/common-auth-embedded/logger/capture-sink.js
 function createCaptureSink() {
-  const records2 = [];
+  const records = [];
   const sink = (record2) => {
-    records2.push(record2);
+    records.push(record2);
   };
   return {
-    records: records2,
+    records,
     sink,
     clear: () => {
-      records2.length = 0;
+      records.length = 0;
     }
   };
 }
@@ -4978,6 +5458,8 @@ var init_redact = __esm({
 
 // ../core/dist/common-auth-embedded/logger/engine.js
 import { appendFileSync, chmodSync, existsSync, renameSync, statSync } from "node:fs";
+import { open as open5 } from "node:fs/promises";
+import { dirname as dirname8, resolve as resolve3 } from "node:path";
 function chmodPrivate(path2) {
   try {
     chmodSync(path2, 384);
@@ -5001,6 +5483,69 @@ function rotateIfNeeded(f) {
   } catch {
   }
 }
+async function closeWindowsFile(sink) {
+  const { file, handle } = sink;
+  sink.file = void 0;
+  sink.handle = void 0;
+  if (file && handle)
+    await privateOperation(file, "log-close", () => handle.close());
+}
+async function openWindowsFile(sink, file) {
+  await ensurePrivateDirectory(dirname8(file));
+  try {
+    await verifyPrivate(file, "file", true);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    try {
+      await createPrivateBytes(file, "");
+    } catch (creationError) {
+      if (creationError.code !== "EEXIST")
+        throw creationError;
+      await verifyPrivate(file, "file", true);
+    }
+  }
+  sink.handle = await privateOperation(file, "log-open", () => open5(file, "a"));
+  sink.file = file;
+  return sink.handle;
+}
+async function flushWindowsFile(sink, file, text2) {
+  file = resolve3(file);
+  try {
+    if (sink.file !== file)
+      await closeWindowsFile(sink);
+    let handle = sink.handle ?? await openWindowsFile(sink, file);
+    const info = await privateOperation(file, "log-stat", () => handle.stat());
+    if (info.size >= MAX_BYTES) {
+      await closeWindowsFile(sink);
+      for (let i = ROTATE_KEEP - 1; i >= 0; i--) {
+        const source = i === 0 ? file : `${file}.${i}`;
+        const target = `${file}.${i + 1}`;
+        try {
+          await verifyPrivate(source, "file", true);
+        } catch (error) {
+          if (error.code === "ENOENT")
+            continue;
+          throw error;
+        }
+        try {
+          await verifyPrivate(target, "file", true);
+        } catch (error) {
+          if (error.code !== "ENOENT")
+            throw error;
+        }
+        await replaceWindowsFile(source, target);
+        await verifyPrivate(target, "file");
+      }
+      handle = await openWindowsFile(sink, file);
+    }
+    await privateOperation(file, "log-append", () => handle.appendFile(text2, "utf8"));
+  } catch (error) {
+    await closeWindowsFile(sink).catch(() => {
+    });
+    throw error;
+  }
+}
 function safeSerialize(data) {
   try {
     return ` ${JSON.stringify(data)}`;
@@ -5016,7 +5561,20 @@ function createEngine(options) {
   let captureSink;
   let buffer = [];
   let timer;
+  let orderedSink = Promise.resolve();
+  let sinkError;
+  const windowsFile = {};
+  function queueWindows(operation) {
+    const next = orderedSink.then(operation);
+    orderedSink = next.catch((error) => {
+      sinkError = error;
+    });
+    return next;
+  }
   function configure(next) {
+    if (windowsPrivateFiles && next.file !== logFileSource)
+      void queueWindows(() => closeWindowsFile(windowsFile)).catch(() => {
+      });
     logFileSource = next.file;
     initLevelSource = next.level;
     redactor = createRedactor(next);
@@ -5040,24 +5598,47 @@ function createEngine(options) {
       return floor;
     return "info";
   }
-  function flushLogs3() {
+  function flushLogs3(close = true) {
     if (timer) {
       clearTimeout(timer);
       timer = void 0;
     }
-    if (!buffer.length)
+    if (!buffer.length) {
+      if (windowsPrivateFiles)
+        return queueWindows(async () => {
+          if (close)
+            await closeWindowsFile(windowsFile);
+          if (sinkError)
+            throw sinkError;
+        });
       return;
+    }
     let file;
     try {
       file = logFilePath();
     } catch {
       buffer = [];
+      if (windowsPrivateFiles && close)
+        return queueWindows(() => closeWindowsFile(windowsFile));
       return;
     }
     const text2 = buffer.join("");
     buffer = [];
-    if (!file)
+    if (!file) {
+      if (windowsPrivateFiles && close)
+        return queueWindows(() => closeWindowsFile(windowsFile));
       return;
+    }
+    if (windowsPrivateFiles) {
+      return queueWindows(async () => {
+        try {
+          await flushWindowsFile(windowsFile, file, text2);
+        } finally {
+          if (close)
+            await closeWindowsFile(windowsFile);
+        }
+      });
+    }
     try {
       rotateIfNeeded(file);
       if (existsSync(file))
@@ -5070,7 +5651,10 @@ function createEngine(options) {
     if (!timer)
       timer = setTimeout(() => {
         timer = void 0;
-        flushLogs3();
+        const flushed = flushLogs3(false);
+        if (flushed instanceof Promise)
+          void flushed.catch(() => {
+          });
       }, 500);
   }
   function emit(channel, level, message, data) {
@@ -5099,9 +5683,12 @@ function createEngine(options) {
       if (logFileSource === void 0)
         return;
       buffer.push(line);
-      if (buffer.length >= 50)
-        flushLogs3();
-      else
+      if (buffer.length >= 50) {
+        const flushed = flushLogs3(false);
+        if (flushed instanceof Promise)
+          void flushed.catch(() => {
+          });
+      } else
         schedule();
     } catch {
     }
@@ -5116,6 +5703,10 @@ function createEngine(options) {
     };
   }
   function reset() {
+    if (windowsPrivateFiles)
+      void queueWindows(() => closeWindowsFile(windowsFile)).catch(() => {
+      });
+    sinkError = void 0;
     buffer = [];
     if (timer) {
       clearTimeout(timer);
@@ -5144,13 +5735,13 @@ function setLogLevel(l) {
   defaultEngine.setLogLevel(l);
 }
 function flushLogs() {
-  defaultEngine.flushLogs();
+  return defaultEngine.flushLogs();
 }
 function createLogger2(channel) {
   return defaultEngine.createLogger(channel);
 }
 async function flushForTest() {
-  defaultEngine.flushLogs();
+  return defaultEngine.flushLogs();
 }
 function resetLoggerForTest() {
   defaultEngine.reset();
@@ -5159,6 +5750,7 @@ var ORDER, MAX_BYTES, ROTATE_KEEP, defaultEngine;
 var init_engine = __esm({
   "../core/dist/common-auth-embedded/logger/engine.js"() {
     "use strict";
+    init_private_files();
     init_redact();
     ORDER = {
       error: 0,
@@ -6695,7 +7287,7 @@ async function select(terminal, items, options) {
       writeLine("");
     renderedLines = lines;
   };
-  return new Promise((resolve7) => {
+  return new Promise((resolve13) => {
     const wasRaw = stdin.isRaw ?? false;
     const cleanup2 = () => {
       if (cleaned)
@@ -6715,7 +7307,7 @@ async function select(terminal, items, options) {
     };
     const finish = (value) => {
       cleanup2();
-      resolve7(value);
+      resolve13(value);
     };
     const onSignal = () => finish(null);
     const onKey = (data) => {
@@ -6755,7 +7347,7 @@ async function select(terminal, items, options) {
       stdin.setRawMode(true);
     } catch {
       cleanup2();
-      resolve7(null);
+      resolve13(null);
       return;
     }
     stdin.resume();
@@ -7523,7 +8115,7 @@ var init_socket = __esm({
         return this.sock.localPort ?? null;
       }
       static connect(host, port, deadlineMs) {
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve13, reject) => {
           const sock = net2.connect({ host, port });
           sock.setNoDelay(true);
           const timer = setTimeout(() => {
@@ -7532,7 +8124,7 @@ var init_socket = __esm({
           }, Math.max(0, deadlineMs - Date.now()));
           sock.once("connect", () => {
             clearTimeout(timer);
-            resolve7(new _SubcSocket(sock));
+            resolve13(new _SubcSocket(sock));
           });
           sock.once("error", (err) => {
             clearTimeout(timer);
@@ -7579,7 +8171,7 @@ var init_socket = __esm({
         }
         if (n === 0)
           return Promise.resolve(new Uint8Array(0));
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve13, reject) => {
           let timer = null;
           if (Number.isFinite(deadlineMs)) {
             const remaining = deadlineMs - Date.now();
@@ -7592,7 +8184,7 @@ var init_socket = __esm({
               reject(new SocketTimeoutError(`timed out waiting for ${n} bytes`));
             }, remaining);
           }
-          this.waiter = { need: n, resolve: resolve7, reject, timer };
+          this.waiter = { need: n, resolve: resolve13, reject, timer };
           this.tryServe();
         });
       }
@@ -7628,7 +8220,7 @@ var init_socket = __esm({
         let queued = false;
         let settled = false;
         let timer = null;
-        const completed = new Promise((resolve7, reject) => {
+        const completed = new Promise((resolve13, reject) => {
           const settle = (run) => {
             if (settled)
               return;
@@ -7652,7 +8244,7 @@ var init_socket = __esm({
                 if (err) {
                   reject(new SocketWriteQueuedError("subc socket reported a write error after bytes were handed to the socket", err instanceof Error ? err : new Error(String(err))));
                 } else {
-                  resolve7();
+                  resolve13();
                 }
               });
             });
@@ -7818,8 +8410,8 @@ function validate(info) {
 async function verifyOwnerOnly(path2) {
   if (process.platform === "win32")
     return;
-  const stat7 = await fs.stat(path2);
-  const mode = stat7.mode & 511;
+  const stat8 = await fs.stat(path2);
+  const mode = stat8.mode & 511;
   if ((mode & 63) !== 0) {
     throw new ConnectionFileError(`connection file ${path2} has insecure permissions 0o${mode.toString(8)}; expected owner-only 0600`);
   }
@@ -8009,7 +8601,7 @@ function normalizeConnectOptions(opts) {
     identity: opts.identity,
     targetKind: opts.targetKind ?? DEFAULT_MANAGED_TARGET_KIND,
     reconnectBackoff: opts.reconnectBackoff ?? DEFAULT_RECONNECT_BACKOFF,
-    sleep: opts.sleep ?? ((ms) => new Promise((resolve7) => setTimeout(resolve7, ms))),
+    sleep: opts.sleep ?? ((ms) => new Promise((resolve13) => setTimeout(resolve13, ms))),
     routeOpenRetryDeadlineMs: opts.routeOpenRetryDeadlineMs ?? ROUTE_OPEN_RETRY_DEADLINE_MS,
     timeoutArbitrationGraceMs: opts.timeoutArbitrationGraceMs ?? TIMEOUT_ARBITRATION_GRACE_MS,
     livenessProbeWindowMs: opts.livenessProbeWindowMs ?? LIVENESS_PROBE_WINDOW_MS,
@@ -8323,15 +8915,15 @@ var init_client = __esm({
         const key = pendingKey(handle, corr);
         let subscriptionPending = null;
         let resolveClosed = null;
-        const closed = new Promise((resolve7, reject) => {
+        const closed = new Promise((resolve13, reject) => {
           if (this.closedErr) {
             reject(this.closedErr);
             return;
           }
-          resolveClosed = resolve7;
+          resolveClosed = resolve13;
           subscriptionPending = {
             handle,
-            resolve: () => resolve7(),
+            resolve: () => resolve13(),
             reject,
             onProgress: onEvent,
             timer: null,
@@ -8457,11 +9049,11 @@ var init_client = __esm({
         const waiters = [];
         for (const pending of this.pending.values()) {
           if (pending.handle === handle && !pending.subscription) {
-            waiters.push(new Promise((resolve7) => {
+            waiters.push(new Promise((resolve13) => {
               const previous = pending.onSettle;
               pending.onSettle = () => {
                 previous?.();
-                resolve7();
+                resolve13();
               };
             }));
           }
@@ -8515,11 +9107,11 @@ var init_client = __esm({
         const channel = handle?.channel ?? 0;
         const epoch = handle?.epoch ?? 0;
         const frame = buildFrame(FrameType.Request, buildFlags(binary, priority, false, admission), channel, epoch, corr, body);
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve13, reject) => {
           const ms = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
           const pending = {
             handle,
-            resolve: resolve7,
+            resolve: resolve13,
             reject,
             onProgress,
             timer: null,
@@ -8606,11 +9198,11 @@ var init_client = __esm({
           }
           return this.outcomeUnknownCallError("connection dropped before the managed call returned a response", error);
         };
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve13, reject) => {
           const ms = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
           const pending = {
             handle,
-            resolve: resolve7,
+            resolve: resolve13,
             reject,
             onProgress,
             timer: null,
@@ -9185,7 +9777,7 @@ var init_dist = __esm({
   }
 });
 
-// ../../node_modules/.bun/@cortexkit+claustrum-client@0.6.2/node_modules/@cortexkit/claustrum-client/dist/detect.js
+// ../../node_modules/.bun/@cortexkit+claustrum-client@0.9.0/node_modules/@cortexkit/claustrum-client/dist/detect.js
 import { readdirSync, statSync as statSync2 } from "node:fs";
 import { tmpdir, userInfo } from "node:os";
 import { join as join5 } from "node:path";
@@ -9265,7 +9857,7 @@ function listSubcConnectionFiles(dir) {
 }
 var PRODUCTION_FILE_NAME, TEMP_PREFIX, TEMP_SUFFIX;
 var init_detect = __esm({
-  "../../node_modules/.bun/@cortexkit+claustrum-client@0.6.2/node_modules/@cortexkit/claustrum-client/dist/detect.js"() {
+  "../../node_modules/.bun/@cortexkit+claustrum-client@0.9.0/node_modules/@cortexkit/claustrum-client/dist/detect.js"() {
     init_dist();
     PRODUCTION_FILE_NAME = "subc-connection.json";
     TEMP_PREFIX = "subc-";
@@ -9273,89 +9865,395 @@ var init_detect = __esm({
   }
 });
 
-// ../../node_modules/.bun/@cortexkit+claustrum-client@0.6.2/node_modules/@cortexkit/claustrum-client/dist/identity.js
-import { createHash as createHash5 } from "node:crypto";
-import { existsSync as existsSync2, realpathSync } from "node:fs";
-import { dirname as dirname7, relative, resolve as resolve2 } from "node:path";
-function storageFingerprint(storagePath) {
-  const absolutePath = storagePath;
-  let canonicalPath;
+// ../../node_modules/.bun/@cortexkit+claustrum-client@0.9.0/node_modules/@cortexkit/claustrum-client/dist/identity.js
+import { createHash as createHash5 } from "node:crypto";
+import { existsSync as existsSync2, realpathSync } from "node:fs";
+import { dirname as dirname9, relative, resolve as resolve4 } from "node:path";
+function storageFingerprint(storagePath) {
+  const absolutePath = storagePath;
+  let canonicalPath;
+  try {
+    canonicalPath = realpathSync(absolutePath);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    let ancestor = absolutePath;
+    while (!existsSync2(ancestor)) {
+      const parent = dirname9(ancestor);
+      if (parent === ancestor)
+        break;
+      ancestor = parent;
+    }
+    canonicalPath = resolve4(realpathSync(ancestor), relative(ancestor, absolutePath));
+  }
+  return createHash5("sha256").update(canonicalPath).digest("hex");
+}
+function storeIdentity(projectRoot, storagePath) {
+  return {
+    project_root: projectRoot,
+    harness: "opencode",
+    session: `store-${storageFingerprint(storagePath)}`
+  };
+}
+var init_identity2 = __esm({
+  "../../node_modules/.bun/@cortexkit+claustrum-client@0.9.0/node_modules/@cortexkit/claustrum-client/dist/identity.js"() {
+  }
+});
+
+// ../../node_modules/.bun/@cortexkit+store@0.2.2/node_modules/@cortexkit/store/dist/descriptor.js
+var init_descriptor = __esm({
+  "../../node_modules/.bun/@cortexkit+store@0.2.2/node_modules/@cortexkit/store/dist/descriptor.js"() {
+  }
+});
+
+// ../../node_modules/.bun/@cortexkit+store@0.2.2/node_modules/@cortexkit/store/dist/derivation.js
+var textEncoder;
+var init_derivation = __esm({
+  "../../node_modules/.bun/@cortexkit+store@0.2.2/node_modules/@cortexkit/store/dist/derivation.js"() {
+    textEncoder = new TextEncoder();
+  }
+});
+
+// ../../node_modules/.bun/@cortexkit+store@0.2.2/node_modules/@cortexkit/store/dist/windows-private-files.js
+async function withWindowsPrivateFiles(operation) {
+  let api;
+  try {
+    api = await import("@cortexkit/private-files");
+  } catch (cause) {
+    throw new Error("@cortexkit/private-files is unavailable; refusing the Windows private operation", { cause });
+  }
+  try {
+    return await operation(api);
+  } catch (cause) {
+    if (cause instanceof api.PrivateFilesUnavailableError) {
+      throw new Error(`@cortexkit/private-files native addon is unavailable; refusing the Windows private operation: ${cause.message}`, { cause });
+    }
+    throw cause;
+  }
+}
+var init_windows_private_files = __esm({
+  "../../node_modules/.bun/@cortexkit+store@0.2.2/node_modules/@cortexkit/store/dist/windows-private-files.js"() {
+  }
+});
+
+// ../../node_modules/.bun/@cortexkit+store@0.2.2/node_modules/@cortexkit/store/dist/owner-only-path.js
+import * as fsAsync from "node:fs/promises";
+import { posix, win32 } from "node:path";
+function* realpath4(path2) {
+  return yield { kind: "realpath", path: path2 };
+}
+function* metadata(kind, path2) {
+  return yield { kind, path: path2 };
+}
+function* accountFile(path2) {
+  return yield { kind: "readFile", path: path2 };
+}
+function refused(path2, reason) {
+  return { ok: false, reason, path: path2 };
+}
+function isMissing(error) {
+  return error?.code === "ENOENT";
+}
+function* resolveTarget(input, paths) {
+  if (!input || input.includes("\0"))
+    throw new Error("invalid path");
+  let candidate = paths.isAbsolute(input) ? input : `${process.cwd()}${paths.sep}${input}`;
+  const suffix = [];
+  for (; ; ) {
+    try {
+      const existing = yield* realpath4(candidate);
+      if (suffix.length && !(yield* metadata("stat", existing)).isDirectory()) {
+        throw new Error("nearest existing ancestor is not a directory");
+      }
+      return { resolved: paths.join(existing, ...suffix), existing, missing: suffix.length > 0 };
+    } catch (error) {
+      if (!isMissing(error))
+        throw error;
+      try {
+        yield* metadata("lstat", candidate);
+      } catch (linkError) {
+        if (!isMissing(linkError))
+          throw linkError;
+        const parent = paths.dirname(candidate);
+        if (parent === candidate)
+          throw error;
+        suffix.unshift(paths.basename(candidate));
+        candidate = parent;
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+async function checkWindows(input, io) {
+  let candidate = input;
+  let missing = false;
+  try {
+    if (!input || input.includes("\0") || !win32.isAbsolute(input))
+      throw new Error("expected an absolute Windows path");
+    for (; ; ) {
+      let entry;
+      try {
+        entry = await io.lstat(candidate);
+      } catch (error) {
+        if (!isMissing(error))
+          throw error;
+        const parent = win32.dirname(candidate);
+        if (parent === candidate)
+          throw error;
+        candidate = parent;
+        missing = true;
+        continue;
+      }
+      if (missing && !entry.isDirectory())
+        throw new Error("nearest existing ancestor is not a directory");
+      await withWindowsPrivateFiles((api) => api.verifyPrivatePath(candidate, entry.isDirectory() ? "directory" : "file"));
+      return { ok: true };
+    }
+  } catch (error) {
+    return refused(candidate, `Windows private-path verification refused: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function accountRecords(bytes, count3) {
+  const text2 = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  const id = (value) => value !== void 0 && /^\d+$/.test(value) && Number.isSafeInteger(Number(value)) && Number(value) <= 4294967295;
+  return text2.split("\n").filter((line) => line.trim() !== "" && !line.trimStart().startsWith("#")).map((line) => {
+    const fields = line.split(":");
+    if (fields.length !== count3 || !fields[0] || /\s/.test(fields[0]) || !id(fields[2]) || count3 === 7 && !id(fields[3]))
+      throw new Error("malformed account record");
+    if (count3 === 4 && fields[3] !== "" && fields[3].split(",").some((name) => !name || /\s/.test(name))) {
+      throw new Error("malformed group members");
+    }
+    return fields;
+  });
+}
+function* privateGroupReason(euid, egid) {
+  const records = [];
+  for (const [path2, count3] of [["/etc/passwd", 7], ["/etc/group", 4]]) {
+    let bytes;
+    try {
+      bytes = yield* accountFile(path2);
+    } catch {
+      return `could not read ${path2} to establish a user-private group`;
+    }
+    try {
+      records.push(accountRecords(bytes, count3));
+    } catch {
+      return `could not parse ${path2} to establish a user-private group`;
+    }
+  }
+  const [passwd, groups] = records;
+  const users = passwd.filter((entry) => Number(entry[2]) === euid);
+  const matchingGroups = groups.filter((entry) => Number(entry[2]) === egid);
+  if (users.length !== 1 || matchingGroups.length !== 1) {
+    return "group-writable ancestor (effective user or group is absent or ambiguous in account files)";
+  }
+  const name = users[0][0];
+  if (matchingGroups[0][3] !== "" && matchingGroups[0][3].split(",").some((member) => member !== name)) {
+    return "group-writable ancestor (other group members)";
+  }
+  if (passwd.some((entry) => Number(entry[2]) !== euid && Number(entry[3]) === egid)) {
+    return "group-writable ancestor (another user's primary group)";
+  }
+  return void 0;
+}
+function* checkUnix(input, euid, egid) {
+  if (euid == null)
+    return refused(input, "could not determine effective uid");
+  let current;
+  try {
+    const target = yield* resolveTarget(input, posix);
+    current = target.missing || (yield* metadata("stat", target.existing)).isDirectory() ? target.existing : posix.dirname(target.existing);
+  } catch {
+    return refused(input, "could not resolve target or its nearest existing ancestor");
+  }
+  let child;
+  let groupProof;
+  let groupChecked = false;
+  for (; ; ) {
+    let entries;
+    try {
+      entries = [yield* metadata("lstat", current), yield* metadata("stat", current)];
+    } catch {
+      return refused(current, "could not inspect ancestor");
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        return refused(current, "ancestor is not a directory");
+      if (entry.uid !== euid && entry.uid !== 0)
+        return refused(current, "foreign owner");
+      if ((entry.mode & 18) === 0)
+        continue;
+      if (entry.uid === 0 && (entry.mode & 512) !== 0) {
+        if (child?.every((value) => value.uid === euid && (value.mode & 18) === 0))
+          continue;
+        return refused(current, "sticky ancestor without an owner-only child");
+      }
+      if ((entry.mode & 2) !== 0)
+        return refused(current, "world-writable ancestor");
+      if ((entry.mode & 512) !== 0 || entry.uid !== euid || egid == null || entry.gid !== egid) {
+        return refused(current, "group-writable ancestor (not a non-sticky user-private group)");
+      }
+      if (!groupChecked) {
+        groupProof = yield* privateGroupReason(euid, egid);
+        groupChecked = true;
+      }
+      if (groupProof)
+        return refused(current, groupProof);
+    }
+    const parent = posix.dirname(current);
+    if (parent === current)
+      return { ok: true };
+    child = entries;
+    current = parent;
+  }
+}
+function policy(input, options) {
+  return checkUnix(input, options.euid === void 0 ? process.geteuid?.() : options.euid, options.egid === void 0 ? process.getegid?.() : options.egid);
+}
+async function checkOwnerOnlyPathAsync(input, options = {}) {
+  const io = {
+    realpath: fsAsync.realpath,
+    lstat: fsAsync.lstat,
+    stat: fsAsync.stat,
+    readFile: fsAsync.readFile,
+    ...options.fs
+  };
+  if ((options.platform ?? process.platform) === "win32")
+    return checkWindows(input, io);
+  const check = policy(input, options);
+  let step = check.next();
+  while (!step.done) {
+    const { kind, path: path2 } = step.value;
+    let value;
+    try {
+      value = await io[kind](path2);
+    } catch (error) {
+      step = check.throw(error);
+      continue;
+    }
+    step = check.next(value);
+  }
+  return step.value;
+}
+var init_owner_only_path = __esm({
+  "../../node_modules/.bun/@cortexkit+store@0.2.2/node_modules/@cortexkit/store/dist/owner-only-path.js"() {
+    init_windows_private_files();
+  }
+});
+
+// ../../node_modules/.bun/@cortexkit+store@0.2.2/node_modules/@cortexkit/store/dist/private-write.js
+import { mkdir as mkdir8, open as open6, realpath as realpath5, rmdir } from "node:fs/promises";
+import { dirname as dirname10 } from "node:path";
+function refusal3(result) {
+  return new Error(`Private creation refused: ${result.reason}: ${result.path}`);
+}
+async function checkUnixParent(path2) {
+  const result = await checkOwnerOnlyPathAsync(dirname10(path2));
+  if (!result.ok)
+    throw refusal3(result);
+}
+async function createPrivateFile(path2, bytes = "") {
+  if (process.platform === "win32") {
+    return withWindowsPrivateFiles((api) => api.createPrivateFile(path2, bytes));
+  }
+  await checkUnixParent(path2);
+  const handle = await open6(path2, "wx", 384);
   try {
-    canonicalPath = realpathSync(absolutePath);
-  } catch (error) {
-    if (error.code !== "ENOENT")
-      throw error;
-    let ancestor = absolutePath;
-    while (!existsSync2(ancestor)) {
-      const parent = dirname7(ancestor);
-      if (parent === ancestor)
-        break;
-      ancestor = parent;
-    }
-    canonicalPath = resolve2(realpathSync(ancestor), relative(ancestor, absolutePath));
+    await handle.writeFile(bytes);
+  } finally {
+    await handle.close();
   }
-  return createHash5("sha256").update(canonicalPath).digest("hex");
 }
-function storeIdentity(projectRoot, storagePath) {
-  return {
-    project_root: projectRoot,
-    harness: "opencode",
-    session: `store-${storageFingerprint(storagePath)}`
-  };
+async function createPrivateDirectory(path2) {
+  if (process.platform === "win32") {
+    return withWindowsPrivateFiles((api) => api.createPrivateDirectory(path2));
+  }
+  const parent = await checkOwnerOnlyPathAsync(dirname10(path2));
+  let stickyParent = false;
+  if (!parent.ok) {
+    stickyParent = parent.reason === STICKY_WITHOUT_CHILD && parent.path === await realpath5(dirname10(path2)).catch(() => void 0);
+    if (!stickyParent)
+      throw refusal3(parent);
+  }
+  await mkdir8(path2, { mode: 448 });
+  if (!stickyParent)
+    return;
+  const created = await checkOwnerOnlyPathAsync(path2);
+  if (!created.ok) {
+    await rmdir(path2).catch(() => void 0);
+    throw refusal3(created);
+  }
 }
-var init_identity2 = __esm({
-  "../../node_modules/.bun/@cortexkit+claustrum-client@0.6.2/node_modules/@cortexkit/claustrum-client/dist/identity.js"() {
+var STICKY_WITHOUT_CHILD;
+var init_private_write = __esm({
+  "../../node_modules/.bun/@cortexkit+store@0.2.2/node_modules/@cortexkit/store/dist/private-write.js"() {
+    init_owner_only_path();
+    init_windows_private_files();
+    STICKY_WITHOUT_CHILD = "sticky ancestor without an owner-only child";
+  }
+});
+
+// ../../node_modules/.bun/@cortexkit+store@0.2.2/node_modules/@cortexkit/store/dist/index.js
+var init_dist2 = __esm({
+  "../../node_modules/.bun/@cortexkit+store@0.2.2/node_modules/@cortexkit/store/dist/index.js"() {
+    init_descriptor();
+    init_derivation();
+    init_owner_only_path();
+    init_private_write();
   }
 });
 
-// ../../node_modules/.bun/@cortexkit+claustrum-client@0.6.2/node_modules/@cortexkit/claustrum-client/dist/ancestor-permissions.js
+// ../../node_modules/.bun/@cortexkit+claustrum-client@0.9.0/node_modules/@cortexkit/claustrum-client/dist/private-path.js
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
-import { readFile as readFile6 } from "node:fs/promises";
-function records(source, count3) {
-  return source.split("\n").filter((line) => line.trim() !== "" && !line.trimStart().startsWith("#")).map((line) => {
-    const fields = line.split(":");
-    if (fields.length !== count3 || !fields[0] || /\s/.test(fields[0]) || !/^\d+$/.test(fields[2]) || !Number.isSafeInteger(Number(fields[2])) || Number(fields[2]) > 4294967295 || count3 === 7 && (!/^\d+$/.test(fields[3]) || !Number.isSafeInteger(Number(fields[3])) || Number(fields[3]) > 4294967295)) {
-      throw new Error("malformed account record");
-    }
-    if (count3 === 4 && fields[3] !== "" && fields[3].split(",").some((name) => name === "" || /\s/.test(name)))
-      throw new Error("malformed group members");
-    return fields;
-  });
-}
-async function acceptsAncestor(metadata, identity = ancestorIdentityContext.getStore() ?? {
-  euid: process.geteuid?.(),
-  egid: process.getegid?.(),
-  passwdPath: "/etc/passwd",
-  groupPath: "/etc/group"
-}) {
-  if ((metadata.mode & 18) === 0 || (metadata.mode & 512) !== 0)
-    return true;
-  if ((metadata.mode & 2) !== 0 || identity.euid === void 0 || identity.egid === void 0 || metadata.uid !== identity.euid || metadata.gid !== identity.egid)
-    return false;
+import { stat as stat5 } from "node:fs/promises";
+import { dirname as dirname11, resolve as resolve5 } from "node:path";
+function notPrivate(subject, result) {
+  return `${subject} ${result.path} is not private: ${result.reason}`;
+}
+function privateCreationCode(error) {
+  const value = error;
+  if (value?.code === "ERR_PRIVATE_FILES_SECURITY" && value.reason === "io-error") {
+    if (value.win32Code === 80 || value.win32Code === 183)
+      return "EEXIST";
+    if (value.win32Code === 2 || value.win32Code === 3)
+      return "ENOENT";
+  }
+  return value?.code;
+}
+async function createPrivateParents(path2) {
   try {
-    const passwd = records(new TextDecoder("utf-8", { fatal: true }).decode(await readFile6(identity.passwdPath)), 7);
-    const groups = records(new TextDecoder("utf-8", { fatal: true }).decode(await readFile6(identity.groupPath)), 4);
-    const users = passwd.filter((entry) => Number(entry[2]) === identity.euid);
-    const matchingGroups = groups.filter((entry) => Number(entry[2]) === identity.egid);
-    if (users.length !== 1 || matchingGroups.length !== 1)
-      return false;
-    const name = users[0][0];
-    return (matchingGroups[0][3] === "" || matchingGroups[0][3].split(",").every((member) => member === name)) && !passwd.some((entry) => Number(entry[2]) !== identity.euid && Number(entry[3]) === identity.egid);
-  } catch {
-    return false;
+    await stat5(path2);
+    return;
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+  const parent = dirname11(path2);
+  if (parent !== path2)
+    await createPrivateParents(parent);
+  try {
+    await createPrivateDirectory(path2);
+  } catch (error) {
+    if (privateCreationCode(error) !== "EEXIST")
+      throw error;
+    if (!(await stat5(path2)).isDirectory())
+      throw error;
   }
 }
-var ancestorIdentityContext;
-var init_ancestor_permissions = __esm({
-  "../../node_modules/.bun/@cortexkit+claustrum-client@0.6.2/node_modules/@cortexkit/claustrum-client/dist/ancestor-permissions.js"() {
-    ancestorIdentityContext = new AsyncLocalStorage2();
+var privatePathContext, checkPrivatePath;
+var init_private_path = __esm({
+  "../../node_modules/.bun/@cortexkit+claustrum-client@0.9.0/node_modules/@cortexkit/claustrum-client/dist/private-path.js"() {
+    init_dist2();
+    privatePathContext = new AsyncLocalStorage2();
+    checkPrivatePath = (path2, options) => checkOwnerOnlyPathAsync(resolve5(path2), privatePathContext.getStore() ?? options);
   }
 });
 
-// ../../node_modules/.bun/@cortexkit+claustrum-client@0.6.2/node_modules/@cortexkit/claustrum-client/dist/enrollment.js
+// ../../node_modules/.bun/@cortexkit+claustrum-client@0.9.0/node_modules/@cortexkit/claustrum-client/dist/enrollment.js
 import { randomBytes as randomBytes3 } from "node:crypto";
-import { chmod as chmod2, mkdir as mkdir8, open as open5, realpath as realpath3, rename as rename5, stat as stat4, unlink as unlink5 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname8, join as join6 } from "node:path";
+import { open as open7, rename as rename6, unlink as unlink6 } from "node:fs/promises";
+import { basename as basename3, dirname as dirname12, join as join6, resolve as resolve6 } from "node:path";
 function validateTokenFile(value) {
   if (!TOKEN_RE.test(value.token))
     throw new Error("enrollment token must be exactly 64 lowercase hex characters");
@@ -9364,61 +10262,57 @@ function validateTokenFile(value) {
   }
 }
 async function refuseWritableAncestor(parent) {
-  let component;
-  try {
-    component = await realpath3(parent);
-  } catch {
-    return;
-  }
-  for (; ; ) {
-    const metadata = await stat4(component).catch(() => void 0);
-    if (metadata && !await acceptsAncestor(metadata)) {
-      throw new Error(`enrollment token ancestor ${component} is group- or world-writable without sticky bit`);
-    }
-    const next = dirname8(component);
-    if (next === component)
-      return;
-    component = next;
-  }
+  const result = await checkPrivatePath(parent);
+  if (!result.ok)
+    throw new Error(notPrivate("enrollment token folder", result));
 }
 async function writeEnrollmentTokenFile(path2, value) {
   validateTokenFile(value);
-  const parent = dirname8(path2);
-  await mkdir8(parent, { recursive: true, mode: 448 });
+  path2 = resolve6(path2);
+  const parent = dirname12(path2);
+  if (process.platform !== "win32")
+    await refuseWritableAncestor(parent);
+  await createPrivateParents(parent);
   await refuseWritableAncestor(parent);
   const temporary = join6(parent, `.${basename3(path2)}.${process.pid}.${randomBytes3(12).toString("hex")}.tmp`);
   let created = false;
   try {
-    const descriptor = await open5(temporary, "wx", 384);
     created = true;
     try {
-      await descriptor.writeFile(`${JSON.stringify(value)}
-`, "utf8");
+      await createPrivateFile(temporary, `${JSON.stringify(value)}
+`);
+    } catch (error) {
+      if (privateCreationCode(error) === "EEXIST")
+        created = false;
+      throw error;
+    }
+    const descriptor = await open7(temporary, "r+");
+    try {
       await descriptor.sync();
-      await chmod2(temporary, 384);
     } finally {
       await descriptor.close();
     }
-    await rename5(temporary, path2);
+    await rename6(temporary, path2);
     created = false;
   } finally {
     if (created)
-      await unlink5(temporary).catch(() => void 0);
+      await unlink6(temporary).catch(() => void 0);
   }
 }
 var TOKEN_RE;
 var init_enrollment = __esm({
-  "../../node_modules/.bun/@cortexkit+claustrum-client@0.6.2/node_modules/@cortexkit/claustrum-client/dist/enrollment.js"() {
-    init_ancestor_permissions();
+  "../../node_modules/.bun/@cortexkit+claustrum-client@0.9.0/node_modules/@cortexkit/claustrum-client/dist/enrollment.js"() {
+    init_dist2();
+    init_private_path();
     TOKEN_RE = /^[0-9a-f]{64}$/;
   }
 });
 
-// ../../node_modules/.bun/@cortexkit+claustrum-client@0.6.2/node_modules/@cortexkit/claustrum-client/dist/handles.js
+// ../../node_modules/.bun/@cortexkit+claustrum-client@0.9.0/node_modules/@cortexkit/claustrum-client/dist/handles.js
 var HANDLE_FILE_CONTRACT;
 var init_handles = __esm({
-  "../../node_modules/.bun/@cortexkit+claustrum-client@0.6.2/node_modules/@cortexkit/claustrum-client/dist/handles.js"() {
-    init_ancestor_permissions();
+  "../../node_modules/.bun/@cortexkit+claustrum-client@0.9.0/node_modules/@cortexkit/claustrum-client/dist/handles.js"() {
+    init_private_path();
     HANDLE_FILE_CONTRACT = {
       maxBytes: 256 * 1024,
       mode: 384,
@@ -9430,15 +10324,16 @@ var init_handles = __esm({
   }
 });
 
-// ../../node_modules/.bun/@cortexkit+claustrum-client@0.6.2/node_modules/@cortexkit/claustrum-client/dist/manifest-lock.js
+// ../../node_modules/.bun/@cortexkit+claustrum-client@0.9.0/node_modules/@cortexkit/claustrum-client/dist/manifest-lock.js
 var init_manifest_lock = __esm({
-  "../../node_modules/.bun/@cortexkit+claustrum-client@0.6.2/node_modules/@cortexkit/claustrum-client/dist/manifest-lock.js"() {
-    init_ancestor_permissions();
+  "../../node_modules/.bun/@cortexkit+claustrum-client@0.9.0/node_modules/@cortexkit/claustrum-client/dist/manifest-lock.js"() {
+    init_dist2();
+    init_private_path();
     init_handles();
   }
 });
 
-// ../../node_modules/.bun/@cortexkit+claustrum-client@0.6.2/node_modules/@cortexkit/claustrum-client/dist/errors.js
+// ../../node_modules/.bun/@cortexkit+claustrum-client@0.9.0/node_modules/@cortexkit/claustrum-client/dist/errors.js
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -9475,7 +10370,7 @@ function hasCredentialError(response) {
 }
 var ERROR_CLASS_WIRE_SET, ClaustrumCredentialError;
 var init_errors2 = __esm({
-  "../../node_modules/.bun/@cortexkit+claustrum-client@0.6.2/node_modules/@cortexkit/claustrum-client/dist/errors.js"() {
+  "../../node_modules/.bun/@cortexkit+claustrum-client@0.9.0/node_modules/@cortexkit/claustrum-client/dist/errors.js"() {
     ERROR_CLASS_WIRE_SET = [
       "transient",
       "permanent",
@@ -9497,7 +10392,7 @@ var init_errors2 = __esm({
   }
 });
 
-// ../../node_modules/.bun/@cortexkit+claustrum-client@0.6.2/node_modules/@cortexkit/claustrum-client/dist/wire.js
+// ../../node_modules/.bun/@cortexkit+claustrum-client@0.9.0/node_modules/@cortexkit/claustrum-client/dist/wire.js
 function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -9598,7 +10493,15 @@ function decodeScopedInventory(response, logUnknownClass) {
     const createdAtMs = row.created_at_ms === void 0 || row.created_at_ms === null ? null : typeof row.created_at_ms === "number" && Number.isFinite(row.created_at_ms) ? row.created_at_ms : void 0;
     if (createdAtMs === void 0)
       throw asCredentialError(response, "invalid_response", logUnknownClass);
+    const planTier = row.plan_tier;
+    if (planTier !== void 0 && (typeof planTier !== "string" || !/^[a-z][a-z0-9_]{0,31}(?![\s\S])/.test(planTier))) {
+      throw asCredentialError(response, "invalid_response", logUnknownClass);
+    }
     const authMethod = row.auth_method;
+    const planTierSource = row.plan_tier_source;
+    if (planTierSource !== void 0 && planTierSource !== "operator" && planTierSource !== "detected") {
+      throw asCredentialError(response, "invalid_response", logUnknownClass);
+    }
     if (authMethod !== void 0 && authMethod !== "apikey" && authMethod !== "chatgpt" && authMethod !== "antigravity" && authMethod !== "oauth") {
       throw asCredentialError(response, "invalid_response", logUnknownClass);
     }
@@ -9619,6 +10522,8 @@ function decodeScopedInventory(response, logUnknownClass) {
       // no ids set. A present non-array is a malformed reply and still refuses.
       providerIds: row.provider_ids === void 0 ? [] : strings(row.provider_ids),
       authMethod,
+      planTier,
+      planTierSource,
       state: row.state,
       refreshAdapter: row.refresh_adapter,
       recordVersion,
@@ -9656,7 +10561,7 @@ function decodeEnrollmentPoll(response, logUnknownClass) {
 }
 var CLAUSTRUM_MODULE_ID, RECONNECT_BACKOFF_MS, ClaustrumClient;
 var init_wire = __esm({
-  "../../node_modules/.bun/@cortexkit+claustrum-client@0.6.2/node_modules/@cortexkit/claustrum-client/dist/wire.js"() {
+  "../../node_modules/.bun/@cortexkit+claustrum-client@0.9.0/node_modules/@cortexkit/claustrum-client/dist/wire.js"() {
     init_dist();
     init_detect();
     init_errors2();
@@ -9902,9 +10807,9 @@ var init_wire = __esm({
   }
 });
 
-// ../../node_modules/.bun/@cortexkit+claustrum-client@0.6.2/node_modules/@cortexkit/claustrum-client/dist/index.js
-var init_dist2 = __esm({
-  "../../node_modules/.bun/@cortexkit+claustrum-client@0.6.2/node_modules/@cortexkit/claustrum-client/dist/index.js"() {
+// ../../node_modules/.bun/@cortexkit+claustrum-client@0.9.0/node_modules/@cortexkit/claustrum-client/dist/index.js
+var init_dist3 = __esm({
+  "../../node_modules/.bun/@cortexkit+claustrum-client@0.9.0/node_modules/@cortexkit/claustrum-client/dist/index.js"() {
     init_detect();
     init_identity2();
     init_enrollment();
@@ -9974,10 +10879,10 @@ var init_errors3 = __esm({
 });
 
 // ../core/dist/common-auth-embedded/claustrum/enrollment.js
-import { createHash as createHash6, randomBytes as randomBytes4, randomUUID as randomUUID9 } from "node:crypto";
+import { createHash as createHash6, randomBytes as randomBytes4, randomUUID as randomUUID10 } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
-import { chmod as chmod3, mkdir as mkdir9, open as open6, readFile as readFile7, realpath as realpath4, rename as rename6, stat as stat5, unlink as unlink6 } from "node:fs/promises";
-import { basename as basename4, dirname as dirname9, extname, isAbsolute as isAbsolute2, join as join7, resolve as resolve3 } from "node:path";
+import { chmod as chmod2, mkdir as mkdir9, open as open8, readFile as readFile7, realpath as realpath6, rename as rename7, stat as stat6, unlink as unlink7 } from "node:fs/promises";
+import { basename as basename4, dirname as dirname13, extname, isAbsolute as isAbsolute2, join as join7, resolve as resolve7 } from "node:path";
 function classifyEnrollmentError(error) {
   if (!(error instanceof ClaustrumCredentialError))
     return void 0;
@@ -10002,7 +10907,7 @@ function getClaustrumEnrollmentPaths(tokenPath) {
   const extension = extname(tokenPath) || ".json";
   const stem = basename4(tokenPath, extname(tokenPath));
   return {
-    statePath: join7(dirname9(tokenPath), `${stem}-state${extension}`),
+    statePath: join7(dirname13(tokenPath), `${stem}-state${extension}`),
     tokenPath
   };
 }
@@ -10010,7 +10915,7 @@ function hostEnrollmentPaths(input) {
   const override = input.override?.trim();
   if (override && !isAbsolute2(override) && !input.cwd)
     throw new ClaustrumConsumerError("invalid-state", "A relative Claustrum enrollment override needs a base directory");
-  const tokenPath = override ? isAbsolute2(override) ? override : resolve3(input.cwd, override) : join7(input.stateDir, `${input.host}-enrollment.json`);
+  const tokenPath = override ? isAbsolute2(override) ? override : resolve7(input.cwd, override) : join7(input.stateDir, `${input.host}-enrollment.json`);
   return getClaustrumEnrollmentPaths(tokenPath);
 }
 function isRecord8(value) {
@@ -10085,15 +10990,15 @@ function decodeTokenFile(value) {
     token_generation: value.token_generation
   };
 }
-function validateReadableSecretFile(metadata) {
-  if (!metadata.isFile()) {
+function validateReadableSecretFile(metadata2) {
+  if (!metadata2.isFile()) {
     throw new ClaustrumConsumerError("unsafe-file", "Claustrum enrollment file must be a regular file");
   }
-  if ((metadata.mode & 63) !== 0) {
+  if ((metadata2.mode & 63) !== 0) {
     throw new ClaustrumConsumerError("unsafe-file", "Claustrum enrollment file must be owner-only");
   }
   const expectedUid = process.geteuid?.();
-  if (expectedUid !== void 0 && metadata.uid !== expectedUid) {
+  if (expectedUid !== void 0 && metadata2.uid !== expectedUid) {
     throw new ClaustrumConsumerError("unsafe-file", "Claustrum enrollment file must be owned by the current user");
   }
 }
@@ -10105,9 +11010,23 @@ function parseSecretJson(text2) {
   }
 }
 async function readBoundedJson(path2) {
+  if (windowsPrivateFiles) {
+    try {
+      await ensurePrivateDirectory(dirname13(path2));
+      const text2 = await readPrivateText(path2, true);
+      if (Buffer.byteLength(text2) > ENROLLMENT_FILE_MAX_BYTES) {
+        throw new ClaustrumConsumerError("unsafe-file", "Claustrum enrollment file is too large");
+      }
+      return parseSecretJson(text2);
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return void 0;
+      throw error;
+    }
+  }
   let descriptor;
   try {
-    descriptor = await open6(path2, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+    descriptor = await open8(path2, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
   } catch (error) {
     if (error.code === "ENOENT")
       return void 0;
@@ -10125,17 +11044,17 @@ async function readBoundedJson(path2) {
     await descriptor.close();
   }
 }
-function accountRecords(text2, fields) {
-  const records2 = [];
+function accountRecords2(text2, fields) {
+  const records = [];
   for (const line of text2.split("\n")) {
     if (line.trim() === "" || line.startsWith("#"))
       continue;
     const parts = line.split(":");
     if (parts.length !== fields || !/^[^\s:,]+$/.test(parts[0] ?? "") || !/^\d+$/.test(parts[2] ?? "") || !Number.isSafeInteger(Number(parts[2])) || fields === 7 && (!/^\d+$/.test(parts[3] ?? "") || !Number.isSafeInteger(Number(parts[3]))) || fields === 4 && parts[3] !== "" && !/^[^\s:,]+(?:,[^\s:,]+)*$/.test(parts[3] ?? ""))
       return void 0;
-    records2.push(parts);
+    records.push(parts);
   }
-  return records2;
+  return records;
 }
 async function isPrivateGroup(uid, gid, options) {
   try {
@@ -10143,8 +11062,8 @@ async function isPrivateGroup(uid, gid, options) {
       readFile7(options.passwdPath ?? "/etc/passwd", "utf8"),
       readFile7(options.groupPath ?? "/etc/group", "utf8")
     ]);
-    const users = accountRecords(passwdText, 7);
-    const groups = accountRecords(groupText, 4);
+    const users = accountRecords2(passwdText, 7);
+    const groups = accountRecords2(groupText, 4);
     if (!users || !groups)
       return false;
     const owners = users.filter((user) => Number(user[2]) === uid);
@@ -10158,71 +11077,95 @@ async function isPrivateGroup(uid, gid, options) {
     return false;
   }
 }
+function ancestorPolicyOptions(options) {
+  if (!options.passwdPath && !options.groupPath)
+    return void 0;
+  return {
+    fs: {
+      readFile: (path2) => readFile7(path2 === "/etc/passwd" ? options.passwdPath ?? path2 : path2 === "/etc/group" ? options.groupPath ?? path2 : path2)
+    }
+  };
+}
 async function refuseWritableAncestor2(parent, options = {}) {
-  const uid = process.geteuid?.();
-  if (uid === void 0)
-    return;
-  const gid = process.getegid?.();
-  let component;
-  try {
-    component = await realpath4(parent);
-  } catch {
-    return;
-  }
-  let privateGroup;
-  for (; ; ) {
-    const metadata = await stat5(component).catch(() => void 0);
-    if (metadata && (metadata.mode & 18) !== 0 && (metadata.mode & 512) === 0) {
-      if (privateGroup === void 0) {
-        privateGroup = gid !== void 0 && await isPrivateGroup(uid, gid, options);
-      }
-      if ((metadata.mode & 2) !== 0 || metadata.uid !== uid || metadata.gid !== gid || !privateGroup) {
-        throw new ClaustrumConsumerError("unsafe-file", `Claustrum enrollment path has a writable ancestor: ${component}. Another user could replace it. Run: chmod g-w,o-w ${component}`);
+  if (!windowsPrivateFiles) {
+    const uid = process.geteuid?.();
+    if (uid === void 0)
+      return;
+    const gid = process.getegid?.();
+    let component;
+    try {
+      component = await realpath6(parent);
+    } catch {
+      return;
+    }
+    let privateGroup;
+    for (; ; ) {
+      const metadata2 = await stat6(component).catch(() => void 0);
+      if (metadata2 && (metadata2.mode & 18) !== 0 && (metadata2.mode & 512) === 0) {
+        if (privateGroup === void 0) {
+          privateGroup = gid !== void 0 && await isPrivateGroup(uid, gid, options);
+        }
+        if ((metadata2.mode & 2) !== 0 || metadata2.uid !== uid || metadata2.gid !== gid || !privateGroup) {
+          throw new ClaustrumConsumerError("unsafe-file", `Claustrum enrollment path has a writable ancestor: ${component}. Another user could replace it. Run: chmod g-w,o-w ${component}`);
+        }
       }
+      const next = dirname13(component);
+      if (next === component)
+        return;
+      component = next;
     }
-    const next = dirname9(component);
-    if (next === component)
-      return;
-    component = next;
+  }
+  try {
+    await verifySafeDirectory(parent, ancestorPolicyOptions(options));
+  } catch (error) {
+    if (!(error instanceof PrivateFileError))
+      throw error;
+    throw new ClaustrumConsumerError("unsafe-file", `Claustrum enrollment parent refused: ${error.path} (${error.reason ?? error.code}). Use a folder that other users cannot write or replace.`);
   }
 }
-async function ensurePrivateDirectory(directory) {
+async function ensurePrivateDirectory2(directory, options = {}) {
+  if (windowsPrivateFiles) {
+    await ensurePrivateDirectory(directory, false, ancestorPolicyOptions(options));
+    return;
+  }
   await mkdir9(directory, { recursive: true, mode: 448 });
-  const metadata = await stat5(directory);
+  const metadata2 = await stat6(directory);
   const uid = process.geteuid?.();
-  if (uid !== void 0 && metadata.uid !== uid) {
+  if (uid !== void 0 && metadata2.uid !== uid) {
     throw new ClaustrumConsumerError("unsafe-file", "Claustrum enrollment directory must be owned by the current user");
   }
-  if ((metadata.mode & 63) !== 0)
-    await chmod3(directory, 448);
+  if ((metadata2.mode & 63) !== 0)
+    await chmod2(directory, 448);
 }
 async function writeStateAtomic(path2, state, ancestorOptions = {}) {
-  const parent = dirname9(path2);
-  await ensurePrivateDirectory(parent);
+  const parent = dirname13(path2);
+  await ensurePrivateDirectory2(parent, ancestorOptions);
   await refuseWritableAncestor2(parent, ancestorOptions);
   const bytes = `${JSON.stringify(state)}
 `;
   if (Buffer.byteLength(bytes) > ENROLLMENT_FILE_MAX_BYTES) {
     throw new ClaustrumConsumerError("invalid-state", "Claustrum enrollment state is too large");
   }
-  const temporary = join7(parent, `.${basename4(path2)}.${process.pid}.${randomUUID9()}.tmp`);
+  if (windowsPrivateFiles)
+    return writePrivateAtomic(path2, bytes);
+  const temporary = join7(parent, `.${basename4(path2)}.${process.pid}.${randomUUID10()}.tmp`);
   let descriptor;
   let created = false;
   try {
-    descriptor = await open6(temporary, "wx", 384);
+    descriptor = await open8(temporary, "wx", 384);
     created = true;
     await descriptor.writeFile(bytes, "utf8");
     await descriptor.chmod(384);
     await descriptor.sync();
     await descriptor.close();
     descriptor = void 0;
-    await rename6(temporary, path2);
+    await rename7(temporary, path2);
     created = false;
   } finally {
     await descriptor?.close().catch(() => {
     });
     if (created)
-      await unlink6(temporary).catch(() => {
+      await unlink7(temporary).catch(() => {
       });
   }
 }
@@ -10313,7 +11256,7 @@ function wrongConsumer() {
   return new ClaustrumConsumerError("wrong-consumer", "Claustrum enrollment state belongs to a different consumer");
 }
 async function resetClaustrumEnrollmentState(paths, proposedName) {
-  await ensurePrivateDirectory(dirname9(paths.statePath));
+  await ensurePrivateDirectory2(dirname13(paths.statePath));
   const lock = await acquireRefreshFileLock({
     name: "ceremony",
     path: paths.statePath,
@@ -10334,7 +11277,7 @@ async function resetClaustrumEnrollmentState(paths, proposedName) {
     if (state.phase === "pending")
       return "refused-pending";
     await lock.assertOwned();
-    await unlink6(paths.statePath);
+    await unlink7(paths.statePath);
     return "reset";
   } finally {
     await lock.release();
@@ -10342,7 +11285,7 @@ async function resetClaustrumEnrollmentState(paths, proposedName) {
 }
 async function removeIfPresent(path2) {
   try {
-    await unlink6(path2);
+    await unlink7(path2);
     return true;
   } catch (error) {
     if (error.code === "ENOENT")
@@ -10351,7 +11294,7 @@ async function removeIfPresent(path2) {
   }
 }
 async function disconnectClaustrumEnrollment(paths, proposedName) {
-  await ensurePrivateDirectory(dirname9(paths.statePath));
+  await ensurePrivateDirectory2(dirname13(paths.statePath));
   const lock = await acquireRefreshFileLock({
     // The same lock as the ceremony, so a token written by a concurrent
     // reconcile() can never land after this removes the files.
@@ -10386,8 +11329,9 @@ var ENROLLMENT_SCHEMA, ENROLLMENT_FILE_MAX_BYTES, ENROLLMENT_LOCK_TTL_MS, TOKEN_
 var init_enrollment2 = __esm({
   "../core/dist/common-auth-embedded/claustrum/enrollment.js"() {
     "use strict";
-    init_dist2();
+    init_dist3();
     init_fs();
+    init_private_files();
     init_errors3();
     ENROLLMENT_SCHEMA = 1;
     ENROLLMENT_FILE_MAX_BYTES = 16 * 1024;
@@ -10439,7 +11383,7 @@ var init_enrollment2 = __esm({
         return statusFromState(blocked);
       }
       async reconcile() {
-        await ensurePrivateDirectory(dirname9(this.#paths.statePath));
+        await ensurePrivateDirectory2(dirname13(this.#paths.statePath), this.#ancestorOptions);
         const lock = await acquireRefreshFileLock({
           name: "ceremony",
           path: this.#paths.statePath,
@@ -10517,17 +11461,17 @@ var init_enrollment2 = __esm({
               };
               await writeStateAtomic(this.#paths.statePath, state, this.#ancestorOptions);
             } catch (error) {
-              const refusal3 = classifyEnrollmentError(error);
-              if (!refusal3)
+              const refusal4 = classifyEnrollmentError(error);
+              if (!refusal4)
                 throw error;
-              if (refusal3.disposition === "retry") {
+              if (refusal4.disposition === "retry") {
                 return {
                   state: "pending",
                   proposedName: state.proposedName,
-                  retryCode: refusal3.code
+                  retryCode: refusal4.code
                 };
               }
-              return this.#block(state, refusal3.code);
+              return this.#block(state, refusal4.code);
             }
           }
           const requestId = state.requestId;
@@ -10550,8 +11494,8 @@ var init_enrollment2 = __esm({
               await writeStateAtomic(this.#paths.statePath, denied, this.#ancestorOptions);
               return statusFromState(denied);
             }
-            await ensurePrivateDirectory(dirname9(this.#paths.tokenPath));
-            await refuseWritableAncestor2(dirname9(this.#paths.tokenPath), this.#ancestorOptions);
+            await ensurePrivateDirectory2(dirname13(this.#paths.tokenPath), this.#ancestorOptions);
+            await refuseWritableAncestor2(dirname13(this.#paths.tokenPath), this.#ancestorOptions);
             await this.#writeTokenFile(this.#paths.tokenPath, {
               token: outcome.token,
               token_generation: outcome.tokenGeneration
@@ -10567,18 +11511,18 @@ var init_enrollment2 = __esm({
             await writeStateAtomic(this.#paths.statePath, approved, this.#ancestorOptions);
             return statusFromState(approved);
           } catch (error) {
-            const refusal3 = classifyEnrollmentError(error);
-            if (!refusal3)
+            const refusal4 = classifyEnrollmentError(error);
+            if (!refusal4)
               throw error;
-            if (refusal3.disposition === "retry") {
+            if (refusal4.disposition === "retry") {
               return {
                 state: "pending",
                 proposedName: state.proposedName,
                 requestId,
-                retryCode: refusal3.code
+                retryCode: refusal4.code
               };
             }
-            return this.#block(state, refusal3.code);
+            return this.#block(state, refusal4.code);
           }
         } finally {
           await lock.release();
@@ -10706,7 +11650,7 @@ var defaultLogger, SERVING_MARGIN_MS, ClaustrumScopedCustody;
 var init_custody = __esm({
   "../core/dist/common-auth-embedded/claustrum/custody.js"() {
     "use strict";
-    init_dist2();
+    init_dist3();
     init_logger();
     init_enrollment2();
     init_errors3();
@@ -10975,7 +11919,6 @@ var init_interlock = __esm({
 
 // ../core/dist/common-auth-embedded/claustrum/roster.js
 import { createHash as createHash7 } from "node:crypto";
-import { readFile as readFile8 } from "node:fs/promises";
 function hash(value) {
   return createHash7("sha256").update(value).digest("hex");
 }
@@ -11138,13 +12081,13 @@ function decodeRow(value) {
 function decodeRejected(value) {
   if (!Array.isArray(value))
     return void 0;
-  const records2 = [];
+  const records = [];
   for (const entry of value) {
     if (!isRecord10(entry) || !optionalString2(entry.credentialId) || typeof entry.reason !== "string" || !SKIPPED_REASONS.has(entry.reason))
       return void 0;
-    records2.push(entry);
+    records.push(entry);
   }
-  return records2;
+  return records;
 }
 function decodeRoster(value) {
   if (!isRecord10(value) || value.version !== 1 || !optionalString2(value.view) || !Array.isArray(value.rows) || !Array.isArray(value.declined) || value.complete !== void 0 && typeof value.complete !== "boolean" || value.rejected !== void 0 && !decodeRejected(value.rejected))
@@ -11177,7 +12120,7 @@ function decodeRoster(value) {
 async function readVaultRoster(path2) {
   let text2;
   try {
-    text2 = await readFile8(path2, "utf8");
+    text2 = await readPrivateText(path2, windowsPrivateFiles);
   } catch (error) {
     if (error.code === "ENOENT")
       return void 0;
@@ -11339,6 +12282,7 @@ var init_roster = __esm({
   "../core/dist/common-auth-embedded/claustrum/roster.js"() {
     "use strict";
     init_fs();
+    init_private_files();
     init_quota();
     init_errors3();
     init_interlock();
@@ -11394,7 +12338,7 @@ var init_consumer = __esm({
           this.#shutdown.signal,
           ...signal ? [signal] : []
         ]);
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve13, reject) => {
           const cleanup2 = () => {
             combined.signal.removeEventListener("abort", abort);
             combined.dispose();
@@ -11409,7 +12353,7 @@ var init_consumer = __esm({
             if (combined.signal.aborted)
               reject(combined.signal.reason);
             else
-              resolve7(value);
+              resolve13(value);
           }, (error) => {
             cleanup2();
             reject(error);
@@ -11688,8 +12632,8 @@ function connectClaustrumScopedClient(options) {
 var init_claustrum = __esm({
   "../core/dist/common-auth-embedded/claustrum/index.js"() {
     "use strict";
-    init_dist2();
-    init_dist2();
+    init_dist3();
+    init_dist3();
     init_consumer();
     init_custody();
     init_enrollment2();
@@ -11702,7 +12646,7 @@ var init_claustrum = __esm({
 
 // ../core/dist/common-auth-embedded/pi-slot/lock.js
 import { rmdirSync, statSync as statSync3 } from "node:fs";
-import { mkdir as mkdir10, rmdir, stat as stat6, utimes } from "node:fs/promises";
+import { mkdir as mkdir10, rmdir as rmdir2, stat as stat7, utimes } from "node:fs/promises";
 function sameDirectory(observed, identity) {
   return observed.dev === identity.dev && observed.ino === identity.ino;
 }
@@ -11714,7 +12658,7 @@ function held() {
 }
 async function remove(path2) {
   try {
-    await rmdir(path2);
+    await rmdir2(path2);
   } catch (error) {
     if (errorCode2(error) !== "ENOENT")
       throw error;
@@ -11730,7 +12674,7 @@ async function acquire(path2, stale) {
       throw held();
     let mtime;
     try {
-      mtime = (await stat6(path2)).mtime.getTime();
+      mtime = (await stat7(path2)).mtime.getTime();
     } catch (error2) {
       if (errorCode2(error2) === "ENOENT")
         return acquire(path2, 0);
@@ -11746,7 +12690,7 @@ async function acquire(path2, stale) {
       const probe = new Date(Math.ceil(Date.now() / 1e3) * 1e3 + 5);
       await utimes(path2, probe, probe);
     }
-    const observed = await stat6(path2);
+    const observed = await stat7(path2);
     const mtime = observed.mtime.getTime();
     precision ??= mtime % 1e3 === 0 ? "s" : "ms";
     return { dev: observed.dev, ino: observed.ino, mtime };
@@ -11797,7 +12741,7 @@ async function acquirePiLock(authPath, onCompromised, onRenew) {
       return;
     let observed;
     try {
-      observed = await stat6(path2);
+      observed = await stat7(path2);
     } catch (error) {
       retry(error);
       return;
@@ -11845,7 +12789,7 @@ async function acquirePiLock(authPath, onCompromised, onRenew) {
       }
       let observed;
       try {
-        observed = await stat6(path2);
+        observed = await stat7(path2);
       } catch (error) {
         if (errorCode2(error) !== "ENOENT")
           throw error;
@@ -11886,8 +12830,8 @@ var init_lock = __esm({
 // ../core/dist/common-auth-embedded/pi-slot/slot.js
 import { createHash as createHash8 } from "node:crypto";
 import { constants as constants2 } from "node:fs";
-import { lstat as lstat2, mkdir as mkdir11, open as open7, unlink as unlink7 } from "node:fs/promises";
-import { dirname as dirname10, resolve as resolve4 } from "node:path";
+import { lstat as lstat4, mkdir as mkdir11, open as open9, unlink as unlink8 } from "node:fs/promises";
+import { dirname as dirname14, resolve as resolve8 } from "node:path";
 import { setTimeout as sleep2 } from "node:timers/promises";
 function rootSpans(text2) {
   let i = text2.indexOf("{") + 1;
@@ -11967,16 +12911,30 @@ function code(error) {
   return object2(error) ? error.code : void 0;
 }
 async function safeRead(path2, privateFile = false, afterReadCheck) {
+  if (windowsPrivateFiles) {
+    try {
+      await afterReadCheck?.(path2);
+      const bytes = await readPrivateBuffer(path2, true);
+      const text2 = bytes.toString("utf8");
+      if (!bytes.equals(Buffer.from(text2)))
+        throw new PiSlotError(privateFile ? "invalid-stash" : "invalid-auth");
+      return text2;
+    } catch (error) {
+      if (code(error) === "ENOENT")
+        return void 0;
+      throw error;
+    }
+  }
   let file;
   try {
-    file = await open7(path2, constants2.O_RDONLY | constants2.O_NOFOLLOW);
-    const stat7 = await file.stat();
-    if (!stat7.isFile() || privateFile && (stat7.mode & 511) !== 384) {
+    file = await open9(path2, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+    const stat8 = await file.stat();
+    if (!stat8.isFile() || privateFile && (stat8.mode & 511) !== 384) {
       throw new PiSlotError("unsafe-path");
     }
     await afterReadCheck?.(path2);
-    const current = await lstat2(path2);
-    if (!current.isFile() || current.dev !== stat7.dev || current.ino !== stat7.ino) {
+    const current = await lstat4(path2);
+    if (!current.isFile() || current.dev !== stat8.dev || current.ino !== stat8.ino) {
       throw new PiSlotError("unsafe-path");
     }
     const bytes = await file.readFile();
@@ -12045,7 +13003,9 @@ function replaceEntry(auth, provider, next) {
   return `${text2.slice(0, offset)}${last ? "," : ""}${JSON.stringify(provider)}:${next}${text2.slice(offset)}`;
 }
 async function syncDir(path2) {
-  const dir = await open7(path2, "r");
+  if (windowsPrivateFiles)
+    return;
+  const dir = await open9(path2, "r");
   try {
     await dir.sync();
   } finally {
@@ -12056,6 +13016,7 @@ async function atomicWrite(path2, text2, assertLock, beforeRename) {
   await writeJsonAtomic2(path2, null, {
     serialize: () => text2,
     durable: true,
+    durability: windowsPrivateFiles ? "file-only-on-windows" : void 0,
     beforeRename: async () => {
       await beforeRename?.(path2);
       assertLock();
@@ -12071,8 +13032,8 @@ function createPiSlot(options, onStep, hooks) {
   if (!provider || !options.authPath || !options.stashPath || !placeholderKey || placeholderKey.startsWith("!") || placeholderKey.includes("$") || !Number.isFinite(timeout) || timeout < 0) {
     throw new PiSlotError("invalid-options");
   }
-  const authPath = resolve4(options.authPath);
-  const stashPath = resolve4(options.stashPath);
+  const authPath = resolve8(options.authPath);
+  const stashPath = resolve8(options.stashPath);
   if (authPath === stashPath || stashPath === `${authPath}.lock`) {
     throw new PiSlotError("invalid-options");
   }
@@ -12104,7 +13065,10 @@ function createPiSlot(options, onStep, hooks) {
         throw new PiSlotError("lock-compromised");
     };
     try {
-      await mkdir11(dirname10(authPath), { recursive: true, mode: 448 });
+      if (windowsPrivateFiles)
+        await ensurePrivateDirectory(dirname14(authPath));
+      else
+        await mkdir11(dirname14(authPath), { recursive: true, mode: 448 });
       const deadline = Date.now() + timeout;
       let retry = 0;
       while (!release) {
@@ -12128,7 +13092,7 @@ function createPiSlot(options, onStep, hooks) {
       assertLock();
       return result;
     } catch (error) {
-      if (error instanceof PiSlotError)
+      if (error instanceof PiSlotError || error instanceof PrivateFileError)
         throw error;
       throw new PiSlotError("io");
     } finally {
@@ -12144,8 +13108,8 @@ function createPiSlot(options, onStep, hooks) {
   }
   async function deleteStash(assertLock) {
     assertLock();
-    await unlink7(stashPath);
-    await syncDir(dirname10(stashPath));
+    await unlink8(stashPath);
+    await syncDir(dirname14(stashPath));
     onStep?.("stash-deleted");
   }
   return {
@@ -12164,10 +13128,14 @@ function createPiSlot(options, onStep, hooks) {
       if (stash && digest2(auth.entry) !== stash.sha256)
         throw new PiSlotError("conflict");
       if (!stash) {
-        await mkdir11(dirname10(stashPath), { recursive: true, mode: 448 });
-        const dir = await lstat2(dirname10(stashPath));
-        if (!dir.isDirectory() || (dir.mode & 511) !== 448)
-          throw new PiSlotError("unsafe-path");
+        if (windowsPrivateFiles)
+          await ensurePrivateDirectory(dirname14(stashPath));
+        else {
+          await mkdir11(dirname14(stashPath), { recursive: true, mode: 448 });
+          const dir = await lstat4(dirname14(stashPath));
+          if (!dir.isDirectory() || (dir.mode & 511) !== 448)
+            throw new PiSlotError("unsafe-path");
+        }
         const saved = {
           version: 1,
           provider,
@@ -12206,6 +13174,7 @@ var init_slot = __esm({
   "../core/dist/common-auth-embedded/pi-slot/slot.js"() {
     "use strict";
     init_atomic_write();
+    init_private_files();
     init_lock();
     PiSlotError = class extends Error {
       code;
@@ -12233,7 +13202,7 @@ var init_pi_slot = __esm({
 
 // src/cli.ts
 import { execFile } from "node:child_process";
-import { resolve as resolve6 } from "node:path";
+import { resolve as resolve12 } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { promisify } from "node:util";
 
@@ -12495,10 +13464,10 @@ var optional = (codec) => ({
   required: false
 });
 var EXTENSIONS = "extensions";
-function buildRecord(shape, open8, options) {
+function buildRecord(shape, open11, options) {
   const forbidden = options.forbidden ?? {};
   const knownField = (key) => Object.hasOwn(shape, key) ? shape[key] : void 0;
-  const refusal3 = (key) => Object.hasOwn(forbidden, key) ? forbidden[key] : void 0;
+  const refusal4 = (key) => Object.hasOwn(forbidden, key) ? forbidden[key] : void 0;
   const requireFields = (present2, path2) => {
     for (const [key, field] of Object.entries(shape)) {
       if (field.required && !Object.hasOwn(present2, key)) {
@@ -12517,10 +13486,10 @@ function buildRecord(shape, open8, options) {
           out[key] = field.codec.decode(value, at);
           continue;
         }
-        const reason = refusal3(key);
+        const reason = refusal4(key);
         if (reason !== void 0)
           fail(at, reason);
-        if (!open8)
+        if (!open11)
           fail(at, "is not a known field");
         extensions ??= {};
         extensions[key] = jsonValue.decode(value, at);
@@ -12535,13 +13504,13 @@ function buildRecord(shape, open8, options) {
       let extensions;
       for (const [key, item] of objectEntries(value, path2)) {
         const at = childPath(path2, key);
-        if (open8 && key === EXTENSIONS) {
+        if (open11 && key === EXTENSIONS) {
           extensions = item;
           continue;
         }
         const field = knownField(key);
         if (!field) {
-          fail(at, open8 ? "is not a known field; unknown data belongs in extensions" : "is not a known field");
+          fail(at, open11 ? "is not a known field; unknown data belongs in extensions" : "is not a known field");
         }
         if (item === void 0) {
           fail(at, "is undefined; leave the key out to keep it absent");
@@ -12555,7 +13524,7 @@ function buildRecord(shape, open8, options) {
           const at = childPath(extensionsPath, key);
           if (knownField(key))
             fail(at, "collides with a known field");
-          const reason = refusal3(key);
+          const reason = refusal4(key);
           if (reason !== void 0)
             fail(at, reason);
           out[key] = jsonValue.encode(item, at);
@@ -12745,10 +13714,10 @@ function isValidProviderState(raw) {
 }
 function providerStateCredentialBound(raw) {
   const stored = encodeProviderState(decodeProviderState(raw));
-  const metadata = asObject(stored.metadata ?? null);
+  const metadata2 = asObject(stored.metadata ?? null);
   const bound = {};
   for (const key of CREDENTIAL_BOUND_METADATA_FIELDS) {
-    const value = metadata[key];
+    const value = metadata2[key];
     if (value !== void 0)
       bound[key] = value;
   }
@@ -12779,12 +13748,12 @@ function decodeRoutingSettings(raw) {
 function encodeRoutingSettings(value) {
   return asObject(routingCodec.encode(value, "$"));
 }
-function createProviderStateCodec(policy) {
-  if (policy === null || typeof policy !== "object") {
+function createProviderStateCodec(policy2) {
+  if (policy2 === null || typeof policy2 !== "object") {
     fail("policy", "must be an object with merge and onReplace rules");
   }
   for (const rule of ["merge", "onReplace"]) {
-    if (typeof policy[rule] !== "function") {
+    if (typeof policy2[rule] !== "function") {
       fail(`policy.${rule}`, "must be a function; the store's default would bypass the repository's rule");
     }
   }
@@ -12792,10 +13761,10 @@ function createProviderStateCodec(policy) {
     validate: isValidProviderState,
     credentialBound: providerStateCredentialBound,
     merge(onDisk, incoming) {
-      return encodeProviderState(policy.merge(decodeProviderState(onDisk), decodeProviderState(incoming)));
+      return encodeProviderState(policy2.merge(decodeProviderState(onDisk), decodeProviderState(incoming)));
     },
     onReplace(previous, replacement) {
-      const next = policy.onReplace(previous === void 0 ? void 0 : decodeProviderState(previous), {
+      const next = policy2.onReplace(previous === void 0 ? void 0 : decodeProviderState(previous), {
         id: replacement.id,
         credentialEpoch: replacement.credentialEpoch,
         ...replacement.previousIdentity !== void 0 ? { previousIdentity: replacement.previousIdentity } : {},
@@ -12991,11 +13960,11 @@ function parseAccount(value, ordinal, version, clock) {
     delete normalized.fingerprint;
     delete normalized.fingerprintHistory;
   }
-  const metadata = decodeProviderMetadata(normalized);
+  const metadata2 = decodeProviderMetadata(normalized);
   return {
     ordinal,
     refreshToken: source.refreshToken,
-    metadata,
+    metadata: metadata2,
     ...quota === void 0 ? {} : { quota }
   };
 }
@@ -13442,10 +14411,10 @@ async function privateDirectory(path2) {
     if (errno(error) !== "EEXIST")
       throw error;
   }
-  const stat7 = await lstat(path2);
-  if (!stat7.isDirectory() || stat7.isSymbolicLink())
+  const stat8 = await lstat(path2);
+  if (!stat8.isDirectory() || stat8.isSymbolicLink())
     throw new AccountMigrationError("successor directory is not a regular directory");
-  privateMode(stat7.mode, 448);
+  privateMode(stat8.mode, 448);
   if (!sameFilesystemPath(await realpath(path2), path2))
     throw new AccountMigrationError("successor directory traverses a symbolic link");
 }
@@ -13657,8 +14626,8 @@ function assertImportedRow(row, manifest, id) {
   healthyRow(row);
   if (row.id !== id || row.identity !== void 0 || rowRef(row).credentialEpoch !== 1 || row.credential?.type !== "oauth" || row.credential.refresh !== manifest.refreshToken || row.credential.access !== void 0 || row.credential.expires !== void 0 || row.enabled !== (manifest.metadata.enabled !== false))
     throw new AccountMigrationError("successor credential, lineage, identity or enabled flag differs from manifest");
-  const metadata = decodeProviderState(row.providerState);
-  if (!isDeepStrictEqual(encodeProviderState(metadata), encodeProviderState({ schemaVersion: 1, metadata: manifest.metadata })) || !isDeepStrictEqual(row.quota, manifest.quota === void 0 ? void 0 : encodeQuotaState(manifest.quota)))
+  const metadata2 = decodeProviderState(row.providerState);
+  if (!isDeepStrictEqual(encodeProviderState(metadata2), encodeProviderState({ schemaVersion: 1, metadata: manifest.metadata })) || !isDeepStrictEqual(row.quota, manifest.quota === void 0 ? void 0 : encodeQuotaState(manifest.quota)))
     throw new AccountMigrationError("successor full metadata, quota or presence differs from manifest");
 }
 async function verifyImported(store, journal) {
@@ -14301,13 +15270,13 @@ async function exportCurrent(store) {
     healthyRow(row);
     if (row.credential?.type !== "oauth")
       throw new AccountMigrationError("rollback cannot export a non-OAuth row");
-    const metadata = decodeProviderState(row.providerState).metadata;
-    if (metadata.enabled !== false !== row.enabled)
+    const metadata2 = decodeProviderState(row.providerState).metadata;
+    if (metadata2.enabled !== false !== row.enabled)
       throw new AccountMigrationError("current enabled encoding differs from native row");
     return {
       ordinal,
       refreshToken: row.credential.refresh,
-      metadata,
+      metadata: metadata2,
       ...row.quota === void 0 ? {} : { quota: decodeQuotaState(row.quota) }
     };
   });
@@ -14842,8 +15811,8 @@ function latest(...times) {
   }
   return result;
 }
-function accessEvidenceAt(metadata) {
-  return latest(metadata.verificationRequiredAt, metadata.accountIneligibleAt, metadata.eligibilityStateUpdatedAt);
+function accessEvidenceAt(metadata2) {
+  return latest(metadata2.verificationRequiredAt, metadata2.accountIneligibleAt, metadata2.eligibilityStateUpdatedAt);
 }
 function mergeExtensions(a, b) {
   if (a === void 0 && b === void 0)
@@ -14922,19 +15891,19 @@ var ACCOUNT_STATE_POLICY = {
     };
   },
   onReplace(previous, replacement) {
-    const metadata = replacementMetadata(previous?.metadata, replacement);
-    if (metadata === void 0)
+    const metadata2 = replacementMetadata(previous?.metadata, replacement);
+    if (metadata2 === void 0)
       return void 0;
     const extensions = mergeExtensions(previous?.extensions, replacement.incoming?.extensions);
     return {
       schemaVersion: PROVIDER_STATE_SCHEMA_VERSION,
-      metadata,
+      metadata: metadata2,
       ...extensions !== void 0 ? { extensions } : {}
     };
   }
 };
-function applyProjectObservation(metadata, observation) {
-  const next = { ...metadata };
+function applyProjectObservation(metadata2, observation) {
+  const next = { ...metadata2 };
   if (observation.projectId !== void 0)
     next.projectId = observation.projectId;
   if (observation.managedProjectId !== void 0) {
@@ -14942,27 +15911,27 @@ function applyProjectObservation(metadata, observation) {
   }
   return next;
 }
-function applyFingerprintObservation(metadata, observation) {
+function applyFingerprintObservation(metadata2, observation) {
   return {
-    ...metadata,
+    ...metadata2,
     fingerprint: observation.fingerprint,
     fingerprintHistory: [...observation.history]
   };
 }
-function applyTierObservation(metadata, observation) {
-  if (typeof metadata.capturedTierAt === "number" && observation.observedAt < metadata.capturedTierAt) {
-    return metadata;
+function applyTierObservation(metadata2, observation) {
+  if (typeof metadata2.capturedTierAt === "number" && observation.observedAt < metadata2.capturedTierAt) {
+    return metadata2;
   }
   return {
-    ...metadata,
+    ...metadata2,
     capturedTierId: observation.tierId,
     capturedPaidTierId: observation.paidTierId,
     capturedTierAt: observation.observedAt,
     capturedTierSchemaVersion: observation.schemaVersion
   };
 }
-function applyCooldownObservation(metadata, observation) {
-  const next = { ...metadata };
+function applyCooldownObservation(metadata2, observation) {
+  const next = { ...metadata2 };
   if (observation === null) {
     delete next.coolingDownUntil;
     delete next.cooldownReason;
@@ -14972,32 +15941,32 @@ function applyCooldownObservation(metadata, observation) {
   }
   return next;
 }
-function applyRateLimitObservation(metadata, resets) {
+function applyRateLimitObservation(metadata2, resets) {
   return {
-    ...metadata,
-    rateLimitResetTimes: mergeRateLimitResets(metadata.rateLimitResetTimes, resets)
+    ...metadata2,
+    rateLimitResetTimes: mergeRateLimitResets(metadata2.rateLimitResetTimes, resets)
   };
 }
-function applySwitch(metadata, reason) {
-  return { ...metadata, lastSwitchReason: reason };
+function applySwitch(metadata2, reason) {
+  return { ...metadata2, lastSwitchReason: reason };
 }
-function applyUsage(metadata, observation, now) {
+function applyUsage(metadata2, observation, now) {
   const today = utcDay(now);
-  const stored = metadata.dailyRequestCounts;
+  const stored = metadata2.dailyRequestCounts;
   const counts = stored != null && stored.date === today ? { ...stored } : { date: today, claude: 0, gemini: 0 };
   counts[observation.family] += 1;
   return {
-    ...metadata,
-    lastUsed: Math.max(metadata.lastUsed, observation.at),
+    ...metadata2,
+    lastUsed: Math.max(metadata2.lastUsed, observation.at),
     dailyRequestCounts: counts
   };
 }
-function applyAccessVerdict(metadata, verdict) {
-  const evidenceAt = accessEvidenceAt(metadata);
+function applyAccessVerdict(metadata2, verdict) {
+  const evidenceAt = accessEvidenceAt(metadata2);
   if (evidenceAt !== void 0 && verdict.observedAt < evidenceAt) {
     return void 0;
   }
-  const next = { ...metadata };
+  const next = { ...metadata2 };
   switch (verdict.kind) {
     case "verification-required": {
       next.verificationRequired = true;
@@ -15030,8 +15999,8 @@ function applyAccessVerdict(metadata, verdict) {
       return { metadata: next, transition: "disable" };
     }
     case "cleared": {
-      const wasBlocked = metadata.verificationRequired === true || metadata.accountIneligible === true;
-      const hadEligibility = metadata.accountIneligible === true || metadata.eligibilityStateUpdatedAt != null;
+      const wasBlocked = metadata2.verificationRequired === true || metadata2.accountIneligible === true;
+      const hadEligibility = metadata2.accountIneligible === true || metadata2.eligibilityStateUpdatedAt != null;
       next.verificationRequired = false;
       delete next.verificationRequiredAt;
       delete next.verificationRequiredReason;
@@ -15060,10 +16029,10 @@ function shownEnvelope(operation, current, row) {
 function metadataOrBase(envelope, row, now) {
   return envelope?.metadata ?? { addedAt: row.addedAt ?? now, lastUsed: 0 };
 }
-function encodeEnvelope(prior, metadata) {
+function encodeEnvelope(prior, metadata2) {
   return encodeProviderState({
     schemaVersion: PROVIDER_STATE_SCHEMA_VERSION,
-    metadata,
+    metadata: metadata2,
     ...prior?.extensions !== void 0 ? { extensions: prior.extensions } : {}
   });
 }
@@ -15821,14 +16790,14 @@ var StoreAccountRepository = class {
     if (row.providerStateDropped !== void 0)
       return void 0;
     const envelope = envelopeOf(row.providerState);
-    const metadata = {
+    const metadata2 = {
       ...metadataOrBase(envelope, row, this.now())
     };
     for (const [key, value] of Object.entries(learnt)) {
       if (value !== void 0)
-        Object.assign(metadata, { [key]: value });
+        Object.assign(metadata2, { [key]: value });
     }
-    return encodeEnvelope(envelope, metadata);
+    return encodeEnvelope(envelope, metadata2);
   }
   recordIdentity(ref, identity) {
     return this.run("recordIdentity", ref.id, async () => {
@@ -15868,10 +16837,10 @@ var StoreAccountRepository = class {
           return this.decline;
         if (transition.kind === "clear")
           return void 0;
-        const metadata = transition.kind === "set" ? transition.metadata : envelope?.metadata;
-        if (metadata === void 0)
+        const metadata2 = transition.kind === "set" ? transition.metadata : envelope?.metadata;
+        if (metadata2 === void 0)
           return void 0;
-        return encodeEnvelope(envelope, { ...metadata, enabled: input.enabled });
+        return encodeEnvelope(envelope, { ...metadata2, enabled: input.enabled });
       };
       const options = seen.providerStateDropped !== void 0 && input.metadata === void 0 ? { attribution: credentialFenceOf(ref) } : { attribution: credentialFenceOf(ref), providerState: mutator };
       const result = input.enabled ? await this.store.enable(ref.id, options) : await this.store.disable(ref.id, input.reason ?? (input.actor === "user" ? "disabled-by-user" : "disabled"), options);
@@ -15881,11 +16850,11 @@ var StoreAccountRepository = class {
   transitionResult(ref, result) {
     if (result.declined)
       return { ref, declined: true };
-    const metadata = metadataOfStored(result.providerState);
+    const metadata2 = metadataOfStored(result.providerState);
     return {
       ref,
       ...result.providerStateOutcome !== void 0 ? { metadataOutcome: result.providerStateOutcome } : {},
-      ...metadata !== void 0 ? { metadata } : {}
+      ...metadata2 !== void 0 ? { metadata: metadata2 } : {}
     };
   }
   recordAccessVerdict(ref, verdict) {
@@ -15940,11 +16909,11 @@ var StoreAccountRepository = class {
       });
       if (stale)
         return { ref, declined: true };
-      const metadata = metadataOfStored(result.providerState);
+      const metadata2 = metadataOfStored(result.providerState);
       return {
         ref,
         metadataOutcome: result.outcome,
-        ...metadata !== void 0 ? { metadata } : {}
+        ...metadata2 !== void 0 ? { metadata: metadata2 } : {}
       };
     });
   }
@@ -15966,11 +16935,11 @@ var StoreAccountRepository = class {
     });
   }
   metadataResult(ref, result) {
-    const metadata = metadataOfStored(result.providerState);
+    const metadata2 = metadataOfStored(result.providerState);
     return {
       ref,
       outcome: result.outcome,
-      ...metadata !== void 0 ? { metadata } : {}
+      ...metadata2 !== void 0 ? { metadata: metadata2 } : {}
     };
   }
   /**
@@ -16024,8 +16993,8 @@ var StoreAccountRepository = class {
           retryable: failure.failure.ambiguous ? false : failure.failure.retryable
         }, { cause: error });
       }
-      const metadata = metadataOfStored(result.providerState);
-      if (metadata?.dailyRequestCounts == null) {
+      const metadata2 = metadataOfStored(result.providerState);
+      if (metadata2?.dailyRequestCounts == null) {
         throw refusal("recordUsage", "unexpected", `row ${ref.id} shows no request counts after the increment`, {
           rowId: ref.id,
           ambiguous: true
@@ -16033,8 +17002,8 @@ var StoreAccountRepository = class {
       }
       return {
         ref,
-        lastUsed: metadata.lastUsed,
-        dailyRequestCounts: metadata.dailyRequestCounts
+        lastUsed: metadata2.lastUsed,
+        dailyRequestCounts: metadata2.dailyRequestCounts
       };
     });
   }
@@ -16585,8 +17554,8 @@ function createAccountRepositoryFactory(modules, factoryOptions = {}) {
 }
 
 // ../core/dist/fingerprint.js
-var AGY_CLI_VERSION = "1.3.3";
-var AGY_CLI_CHANGE_LIST = "996823801";
+var AGY_CLI_VERSION = "1.3.5";
+var AGY_CLI_CHANGE_LIST = "998863838";
 function normalizeHarnessPlatform(platform = process.platform) {
   return platform === "win32" ? "windows" : platform || "unknown";
 }
@@ -16642,8 +17611,8 @@ function defineModel(id, model) {
   };
 }
 var ALL_MODEL_DEFINITIONS = {
-  "antigravity-gemini-3.5-flash": defineModel("antigravity-gemini-3.5-flash", {
-    name: "Gemini 3.5 Flash (Antigravity)",
+  "antigravity-gemini-4-argon": defineModel("antigravity-gemini-4-argon", {
+    name: "Gemini 4 Argon (Antigravity)",
     reasoning: true,
     limit: { context: 1048576, output: 65536 },
     modalities: DEFAULT_MODALITIES,
@@ -16653,24 +17622,8 @@ var ALL_MODEL_DEFINITIONS = {
       high: { thinkingLevel: "high" }
     }
   }),
-  "antigravity-gemini-3.1-flash-image": defineModel("antigravity-gemini-3.1-flash-image", {
-    name: "Gemini 3.1 Flash Image (Antigravity)",
-    reasoning: false,
-    limit: { context: 66e3, output: 33e3 },
-    modalities: { input: ["text", "image"], output: ["text", "image"] }
-  }),
-  "antigravity-gemini-3.1-pro": defineModel("antigravity-gemini-3.1-pro", {
-    name: "Gemini 3.1 Pro (Antigravity)",
-    reasoning: true,
-    limit: { context: 1048576, output: 65535 },
-    modalities: DEFAULT_MODALITIES,
-    variants: {
-      low: { thinkingLevel: "low" },
-      high: { thinkingLevel: "high" }
-    }
-  }),
-  "antigravity-gemini-3.8-flash": defineModel("antigravity-gemini-3.8-flash", {
-    name: "Gemini 3.8 Flash (Antigravity)",
+  "antigravity-gemini-3.5-flash": defineModel("antigravity-gemini-3.5-flash", {
+    name: "Gemini 3.5 Flash (Antigravity)",
     reasoning: true,
     limit: { context: 1048576, output: 65536 },
     modalities: DEFAULT_MODALITIES,
@@ -16680,19 +17633,14 @@ var ALL_MODEL_DEFINITIONS = {
       high: { thinkingLevel: "high" }
     }
   }),
-  "antigravity-gemini-3.7-flash": defineModel("antigravity-gemini-3.7-flash", {
-    name: "Gemini 3.7 Flash (Antigravity)",
-    reasoning: true,
-    limit: { context: 1048576, output: 65536 },
-    modalities: DEFAULT_MODALITIES,
-    variants: {
-      low: { thinkingLevel: "low" },
-      medium: { thinkingLevel: "medium" },
-      high: { thinkingLevel: "high" }
-    }
+  "antigravity-gemini-3.1-flash-image": defineModel("antigravity-gemini-3.1-flash-image", {
+    name: "Gemini 3.1 Flash Image (Antigravity)",
+    reasoning: false,
+    limit: { context: 66e3, output: 33e3 },
+    modalities: { input: ["text", "image"], output: ["text", "image"] }
   }),
-  "antigravity-gemini-3.6-flash": defineModel("antigravity-gemini-3.6-flash", {
-    name: "Gemini 3.6 Flash (Antigravity)",
+  "antigravity-gemini-3.8-flash": defineModel("antigravity-gemini-3.8-flash", {
+    name: "Gemini 3.8 Flash (Antigravity)",
     reasoning: true,
     limit: { context: 1048576, output: 65536 },
     modalities: DEFAULT_MODALITIES,
@@ -16786,6 +17734,9 @@ var ALL_MODEL_DEFINITIONS = {
   })
 };
 var RESOLVER_ALIASES = {
+  "gemini-4-argon-low": "gemini-4-argon",
+  "gemini-4-argon-medium": "gemini-4-argon",
+  "gemini-4-argon-high": "gemini-4-argon",
   "gemini-3.1-pro-low": "gemini-3.1-pro",
   "gemini-3.1-pro-high": "gemini-3.1-pro",
   "gemini-3-flash-low": "gemini-3-flash",
@@ -16847,12 +17798,10 @@ var QUOTA_GROUP_BY_MODEL_ID = {
   "gpt-oss-120b-medium": "non-gemini"
 };
 var ANTIGRAVITY_OPENCODE_MODEL_IDS = [
+  "antigravity-gemini-4-argon",
   "antigravity-gemini-3.8-flash",
-  "antigravity-gemini-3.7-flash",
-  "antigravity-gemini-3.6-flash",
   "antigravity-gemini-3.5-flash",
   "antigravity-gemini-3.1-flash-image",
-  "antigravity-gemini-3.1-pro",
   "antigravity-claude-sonnet-5-5",
   "antigravity-claude-opus-5-5",
   "antigravity-gpt-oss-120b-medium"
@@ -16866,6 +17815,8 @@ function getResolverAliasMap() {
 }
 function getQuotaGroupForModel(modelId) {
   const normalized = modelId.toLowerCase();
+  if (isGeminiArgonModel(normalized))
+    return void 0;
   return QUOTA_GROUP_BY_MODEL_ID[normalized] ?? // Check Claude / GPT-OSS substrings BEFORE the `gemini` substring so
   // a `gemini-claude-*` alias (which is a Claude route exposed under
   // a `gemini-` namespace) attributes to the non-gemini pool rather
@@ -16873,6 +17824,9 @@ function getQuotaGroupForModel(modelId) {
   // alias IDs start with `gemini-` but contain `claude`.
   (normalized.includes("claude") || normalized.includes("gpt-oss") ? "non-gemini" : normalized.startsWith("gemini") || normalized.startsWith("tab_") ? "gemini" : void 0);
 }
+function isGeminiArgonModel(model) {
+  return /^(?:antigravity-)?gemini-4-argon(?:-(?:low|medium|high))?$/.test(model.toLowerCase());
+}
 
 // ../core/dist/account-selector.js
 var ACCOUNT_SESSION_STATE_TTL_MS = 24 * 60 * 60 * 1e3;
@@ -16968,7 +17922,7 @@ async function rmEvictingDir(evictingPath) {
   });
 }
 async function sleep(ms) {
-  await new Promise((resolve7) => setTimeout(resolve7, ms));
+  await new Promise((resolve13) => setTimeout(resolve13, ms));
 }
 async function acquireFencedFileLock(options) {
   const lockPath = `${options.path}.${options.name}.lock`;
@@ -17084,8 +18038,8 @@ function buildLock(lockPath, evictingPath, ownerId, options, now) {
   let released = false;
   let lost = false;
   let lostResolve = null;
-  let lostPromise = new Promise((resolve7) => {
-    lostResolve = resolve7;
+  let lostPromise = new Promise((resolve13) => {
+    lostResolve = resolve13;
   });
   const markLost = () => {
     if (lost)
@@ -17095,9 +18049,9 @@ function buildLock(lockPath, evictingPath, ownerId, options, now) {
       clearInterval(renewTimer);
       renewTimer = null;
     }
-    const resolve7 = lostResolve;
+    const resolve13 = lostResolve;
     lostResolve = null;
-    resolve7?.();
+    resolve13?.();
   };
   const setupRenew = () => {
     if (options.renew === false)
@@ -17321,7 +18275,7 @@ var AccountStorageUnreadableError = class extends Error {
   }
 };
 var RETRY_DELAYS_MS = [100, 200, 400, 800, 1e3];
-var DEFAULT_SLEEP = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
+var DEFAULT_SLEEP = (ms) => new Promise((resolve13) => setTimeout(resolve13, ms));
 var DEFAULT_BUILD_BACKUP_PATH = (path2, now) => `${path2}.corrupt-${now.toISOString().replace(/[:.]/g, "-")}`;
 async function ensureSecurePermissions(path2) {
   try {
@@ -17832,7 +18786,7 @@ function getHttpsProxy(url) {
   }
 }
 function waitForHead(socket, timeoutMs, onTimeout) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve13, reject) => {
     let buffer = Buffer2.alloc(0);
     const timeout = setTimeout(() => {
       onTimeout();
@@ -17855,7 +18809,7 @@ function waitForHead(socket, timeoutMs, onTimeout) {
         return;
       const head = buffer.subarray(0, marker).toString("latin1");
       const leftover = buffer.subarray(marker + 4);
-      cleanup2(() => resolve7({ head, leftover }));
+      cleanup2(() => resolve13({ head, leftover }));
     };
     socket.on("data", onData);
     socket.once("error", onError);
@@ -17869,7 +18823,7 @@ async function connectViaProxy(proxyUrl, targetUrl, timeoutMs, signal, onDebug)
     port: Number(proxyUrl.port || DEFAULT_PROXY_PORT),
     signal: signal ?? void 0
   });
-  await new Promise((resolve7, reject) => {
+  await new Promise((resolve13, reject) => {
     const timeout = setTimeout(() => {
       onDebug?.(`agy transport proxy connect timeout after ${timeoutMs}ms`);
       proxySocket.destroy();
@@ -17878,7 +18832,7 @@ async function connectViaProxy(proxyUrl, targetUrl, timeoutMs, signal, onDebug)
     const cleanup2 = () => clearTimeout(timeout);
     proxySocket.once("connect", () => {
       cleanup2();
-      resolve7();
+      resolve13();
     });
     proxySocket.once("error", (error) => {
       cleanup2();
@@ -17903,7 +18857,7 @@ Host: ${targetHost}:${targetPort}\r
   if (leftover.length > 0) {
     proxySocket.unshift(leftover);
   }
-  return await new Promise((resolve7, reject) => {
+  return await new Promise((resolve13, reject) => {
     const tlsOptions = {
       socket: proxySocket,
       servername: targetHost,
@@ -17918,7 +18872,7 @@ Host: ${targetHost}:${targetPort}\r
     const cleanup2 = () => clearTimeout(timeout);
     tlsSocket.once("secureConnect", () => {
       cleanup2();
-      resolve7(tlsSocket);
+      resolve13(tlsSocket);
     });
     tlsSocket.once("error", (error) => {
       cleanup2();
@@ -17927,7 +18881,7 @@ Host: ${targetHost}:${targetPort}\r
   });
 }
 async function connectDirect(targetUrl, timeoutMs, signal, onDebug) {
-  return await new Promise((resolve7, reject) => {
+  return await new Promise((resolve13, reject) => {
     const tlsOptions = {
       host: targetUrl.hostname,
       port: Number(targetUrl.port || DEFAULT_HTTPS_PORT),
@@ -17943,7 +18897,7 @@ async function connectDirect(targetUrl, timeoutMs, signal, onDebug) {
     const cleanup2 = () => clearTimeout(timeout);
     socket.once("secureConnect", () => {
       cleanup2();
-      resolve7(socket);
+      resolve13(socket);
     });
     socket.once("error", (error) => {
       cleanup2();
@@ -18577,8 +19531,8 @@ function getDefaultTierId(allowedTiers) {
   return allowedTiers[0]?.id;
 }
 function wait(ms) {
-  return new Promise((resolve7) => {
-    setTimeout(resolve7, ms);
+  return new Promise((resolve13) => {
+    setTimeout(resolve13, ms);
   });
 }
 function extractManagedProjectId(payload) {
@@ -19017,6 +19971,8 @@ function hashKey(key) {
   return createHash9("sha256").update(key).digest("hex").slice(0, 8);
 }
 function classifyQuotaGroup(modelName, displayName) {
+  if (isGeminiArgonModel(modelName))
+    return null;
   const registryGroup = getQuotaGroupForModel(modelName);
   if (registryGroup) {
     return registryGroup;
@@ -19432,10 +20388,183 @@ import {
   writeFileSync
 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname11, join as join9, resolve as resolve5 } from "node:path";
+import { dirname as dirname17, join as join9, resolve as resolve11 } from "node:path";
 
 // src/common-auth-embedded/logger/engine.js
 import { appendFileSync as appendFileSync2, chmodSync as chmodSync2, existsSync as existsSync3, renameSync as renameSync2, statSync as statSync4 } from "node:fs";
+import { open as open10 } from "node:fs/promises";
+import { dirname as dirname16, resolve as resolve10 } from "node:path";
+
+// src/common-auth-embedded/fs/private-files.js
+import { lstat as lstat5, readFile as readFile8, rename as rename8, unlink as unlink9 } from "node:fs/promises";
+import { dirname as dirname15, resolve as resolve9 } from "node:path";
+var windowsPrivateFiles2 = process.platform === "win32";
+var migrationNotices2 = /* @__PURE__ */ new Set();
+function ioCode2(detail) {
+  if (detail?.reason === "io-error") {
+    if (detail.win32Code === 2 || detail.win32Code === 3)
+      return "ENOENT";
+    if (detail.win32Code === 80 || detail.win32Code === 183)
+      return "EEXIST";
+  }
+  return detail?.code ?? "ERR_PRIVATE_FILE";
+}
+var backend2;
+function loadBackend2() {
+  backend2 ??= import("@cortexkit/private-files");
+  return backend2;
+}
+var PrivateFileError2 = class extends Error {
+  path;
+  stage;
+  code;
+  win32Code;
+  reason;
+  published = false;
+  durabilityConfirmed = false;
+  fileDurable = false;
+  attempts = 0;
+  elapsedMs = 0;
+  orphanPath;
+  constructor(path2, stage, cause) {
+    const detail = cause;
+    super(`Private file refused at ${stage}: ${path2} (${detail?.reason ?? detail?.code ?? "io-error"}). Use a safe parent directory. Repair only a named secret file in safe ancestry whose owner the published policy trusts, without changing its owner or any existing directory. Previously exposed credentials may need rotation. Windows requires the private-files native prebuild and an ACL-persisting local filesystem such as NTFS.`, { cause });
+    this.path = path2;
+    this.stage = stage;
+    this.name = "PrivateFileError";
+    this.code = ioCode2(detail);
+    this.win32Code = detail?.win32Code;
+    this.reason = detail?.reason;
+  }
+};
+async function privateOperation2(path2, stage, operation) {
+  try {
+    return await operation();
+  } catch (cause) {
+    if (cause instanceof PrivateFileError2)
+      throw cause;
+    throw new PrivateFileError2(path2, stage, cause);
+  }
+}
+var safeParentOptionsForTest2;
+async function verifySafeDirectory2(path2, options) {
+  path2 = resolve9(path2);
+  options ??= safeParentOptionsForTest2;
+  await privateOperation2(path2, "safe-parent", async () => {
+    const result = await (await loadBackend2()).verifySafeParent(path2, options);
+    if (result.ok === false) {
+      if (result.reason === "io-error" || result.reason === "wrong-kind")
+        await lstat5(path2);
+      throw new PrivateFileError2(result.level ?? result.path, "safe-parent", {
+        ...result,
+        code: "ERR_PRIVATE_FILES_SECURITY"
+      });
+    }
+  });
+}
+async function verifyPrivate2(path2, kind, migrate = false) {
+  path2 = resolve9(path2);
+  if (kind === "directory")
+    return verifySafeDirectory2(path2);
+  await privateOperation2(path2, "verify", async () => {
+    const api = await loadBackend2();
+    const result = await api.verifyOwnerOnly(path2);
+    let repaired = false;
+    if (!result.ok) {
+      const { reason } = result.refusal;
+      if (reason === "io-error")
+        await api.verifyPrivatePath(path2, kind);
+      if (migrate && [
+        api.EXTRA_ACE,
+        api.NOT_PROTECTED,
+        api.NULL_DACL,
+        api.EMPTY_DACL
+      ].includes(reason)) {
+        await verifySafeDirectory2(dirname15(path2));
+        await api.securePrivatePath(path2, kind);
+        repaired = true;
+      } else {
+        throw Object.assign(new Error("Owner-only verification refused"), {
+          reason,
+          code: "ERR_PRIVATE_FILES_SECURITY"
+        });
+      }
+    }
+    await api.verifyPrivatePath(path2, kind);
+    if (repaired && !migrationNotices2.has(path2)) {
+      migrationNotices2.add(path2);
+      process.emitWarning(`Private permissions tightened: ${path2}. This object may have been readable before; rotate credentials if needed.`, "PrivateFileMigration");
+    }
+  });
+}
+async function ensurePrivateDirectory3(path2, _migrate = false, options) {
+  path2 = resolve9(path2);
+  await privateOperation2(path2, "directory", async () => {
+    const api = await loadBackend2();
+    try {
+      await lstat5(path2);
+      return await verifySafeDirectory2(path2, options);
+    } catch (error) {
+      if (ioCode2(error) !== "ENOENT")
+        throw error;
+    }
+    const parent = dirname15(path2);
+    if (parent === path2)
+      throw Object.assign(new Error("Missing root"), { code: "ENOENT" });
+    await ensurePrivateDirectory3(parent, false, options);
+    try {
+      await api.createOwnerOnly(path2, { kind: "dir" });
+    } catch (error) {
+      if (ioCode2(error) !== "EEXIST")
+        throw error;
+    }
+    await verifySafeDirectory2(path2, options);
+  });
+}
+async function createPrivateBytes2(path2, bytes) {
+  await verifySafeDirectory2(dirname15(resolve9(path2)));
+  await privateOperation2(path2, "create", async () => {
+    await (await loadBackend2()).createPrivateFile(resolve9(path2), bytes);
+  });
+}
+async function replaceWindowsFile2(from, to, options = {}) {
+  from = resolve9(from);
+  to = resolve9(to);
+  const now = options.now ?? (() => performance.now());
+  const start = now();
+  const deadline = Math.min(start + 500, options.deadline ?? Infinity);
+  const delays = [0, 10, 20, 40, 80, 100];
+  let original;
+  let attempts = 0;
+  for (const delay of delays) {
+    if (now() >= deadline)
+      break;
+    if (delay)
+      await (options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms))))(Math.min(delay, Math.max(0, deadline - now())));
+    if (now() >= deadline)
+      break;
+    await options.beforeRename?.();
+    if (now() >= deadline)
+      break;
+    attempts++;
+    try {
+      await (options.rename ?? rename8)(from, to);
+      return { attempts, elapsedMs: now() - start };
+    } catch (error2) {
+      original ??= error2;
+      const detail = error2;
+      const candidate = detail.win32Code !== void 0 ? detail.win32Code === 32 || detail.win32Code === 33 : ["EBUSY", "EPERM", "EACCES"].includes(detail.code ?? "") && !detail.reason;
+      if (!candidate)
+        break;
+    }
+  }
+  const error = new PrivateFileError2(to, "rename", original ?? Object.assign(new Error("Publication deadline expired"), {
+    code: "ETIMEDOUT"
+  }));
+  error.attempts = attempts;
+  error.elapsedMs = now() - start;
+  throw error;
+}
 
 // src/common-auth-embedded/logger/redact.js
 var SECRET_KEY_EXACT2 = /^(authorization|x-api-key|cookie|set-cookie|refresh|access|token)$/i;
@@ -19534,6 +20663,69 @@ function rotateIfNeeded2(f) {
   } catch {
   }
 }
+async function closeWindowsFile2(sink) {
+  const { file, handle } = sink;
+  sink.file = void 0;
+  sink.handle = void 0;
+  if (file && handle)
+    await privateOperation2(file, "log-close", () => handle.close());
+}
+async function openWindowsFile2(sink, file) {
+  await ensurePrivateDirectory3(dirname16(file));
+  try {
+    await verifyPrivate2(file, "file", true);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    try {
+      await createPrivateBytes2(file, "");
+    } catch (creationError) {
+      if (creationError.code !== "EEXIST")
+        throw creationError;
+      await verifyPrivate2(file, "file", true);
+    }
+  }
+  sink.handle = await privateOperation2(file, "log-open", () => open10(file, "a"));
+  sink.file = file;
+  return sink.handle;
+}
+async function flushWindowsFile2(sink, file, text2) {
+  file = resolve10(file);
+  try {
+    if (sink.file !== file)
+      await closeWindowsFile2(sink);
+    let handle = sink.handle ?? await openWindowsFile2(sink, file);
+    const info = await privateOperation2(file, "log-stat", () => handle.stat());
+    if (info.size >= MAX_BYTES2) {
+      await closeWindowsFile2(sink);
+      for (let i = ROTATE_KEEP2 - 1; i >= 0; i--) {
+        const source = i === 0 ? file : `${file}.${i}`;
+        const target = `${file}.${i + 1}`;
+        try {
+          await verifyPrivate2(source, "file", true);
+        } catch (error) {
+          if (error.code === "ENOENT")
+            continue;
+          throw error;
+        }
+        try {
+          await verifyPrivate2(target, "file", true);
+        } catch (error) {
+          if (error.code !== "ENOENT")
+            throw error;
+        }
+        await replaceWindowsFile2(source, target);
+        await verifyPrivate2(target, "file");
+      }
+      handle = await openWindowsFile2(sink, file);
+    }
+    await privateOperation2(file, "log-append", () => handle.appendFile(text2, "utf8"));
+  } catch (error) {
+    await closeWindowsFile2(sink).catch(() => {
+    });
+    throw error;
+  }
+}
 function safeSerialize2(data) {
   try {
     return ` ${JSON.stringify(data)}`;
@@ -19549,7 +20741,20 @@ function createEngine2(options) {
   let captureSink;
   let buffer = [];
   let timer;
+  let orderedSink = Promise.resolve();
+  let sinkError;
+  const windowsFile = {};
+  function queueWindows(operation) {
+    const next = orderedSink.then(operation);
+    orderedSink = next.catch((error) => {
+      sinkError = error;
+    });
+    return next;
+  }
   function configure(next) {
+    if (windowsPrivateFiles2 && next.file !== logFileSource)
+      void queueWindows(() => closeWindowsFile2(windowsFile)).catch(() => {
+      });
     logFileSource = next.file;
     initLevelSource = next.level;
     redactor = createRedactor2(next);
@@ -19573,24 +20778,47 @@ function createEngine2(options) {
       return floor;
     return "info";
   }
-  function flushLogs3() {
+  function flushLogs3(close = true) {
     if (timer) {
       clearTimeout(timer);
       timer = void 0;
     }
-    if (!buffer.length)
+    if (!buffer.length) {
+      if (windowsPrivateFiles2)
+        return queueWindows(async () => {
+          if (close)
+            await closeWindowsFile2(windowsFile);
+          if (sinkError)
+            throw sinkError;
+        });
       return;
+    }
     let file;
     try {
       file = logFilePath();
     } catch {
       buffer = [];
+      if (windowsPrivateFiles2 && close)
+        return queueWindows(() => closeWindowsFile2(windowsFile));
       return;
     }
     const text2 = buffer.join("");
     buffer = [];
-    if (!file)
+    if (!file) {
+      if (windowsPrivateFiles2 && close)
+        return queueWindows(() => closeWindowsFile2(windowsFile));
       return;
+    }
+    if (windowsPrivateFiles2) {
+      return queueWindows(async () => {
+        try {
+          await flushWindowsFile2(windowsFile, file, text2);
+        } finally {
+          if (close)
+            await closeWindowsFile2(windowsFile);
+        }
+      });
+    }
     try {
       rotateIfNeeded2(file);
       if (existsSync3(file))
@@ -19603,7 +20831,10 @@ function createEngine2(options) {
     if (!timer)
       timer = setTimeout(() => {
         timer = void 0;
-        flushLogs3();
+        const flushed = flushLogs3(false);
+        if (flushed instanceof Promise)
+          void flushed.catch(() => {
+          });
       }, 500);
   }
   function emit(channel, level, message, data) {
@@ -19632,9 +20863,12 @@ function createEngine2(options) {
       if (logFileSource === void 0)
         return;
       buffer.push(line);
-      if (buffer.length >= 50)
-        flushLogs3();
-      else
+      if (buffer.length >= 50) {
+        const flushed = flushLogs3(false);
+        if (flushed instanceof Promise)
+          void flushed.catch(() => {
+          });
+      } else
         schedule();
     } catch {
     }
@@ -19649,6 +20883,10 @@ function createEngine2(options) {
     };
   }
   function reset() {
+    if (windowsPrivateFiles2)
+      void queueWindows(() => closeWindowsFile2(windowsFile)).catch(() => {
+      });
+    sinkError = void 0;
     buffer = [];
     if (timer) {
       clearTimeout(timer);
@@ -20192,13 +21430,13 @@ function closeDebugLog() {
   if (!state || !current) return Promise.resolve();
   state.logStream = null;
   if (state.logFilePath) liveLogFilePaths.delete(state.logFilePath);
-  return new Promise((resolve7) => {
-    current.once("close", () => resolve7());
-    current.once("error", () => resolve7());
+  return new Promise((resolve13) => {
+    current.once("close", () => resolve13());
+    current.once("error", () => resolve13());
     try {
       current.end();
     } catch {
-      resolve7();
+      resolve13();
     }
   });
 }
@@ -20500,7 +21738,7 @@ var LegacyAccountPoolRetiredError = class extends Error {
 };
 async function assertLegacyPoolInUse(legacyPath) {
   try {
-    await assertLegacyAccountStorageWritable(resolve5(legacyPath));
+    await assertLegacyAccountStorageWritable(resolve11(legacyPath));
   } catch (error) {
     throw new LegacyAccountPoolRetiredError(legacyPath, { cause: error });
   }
@@ -20508,7 +21746,7 @@ async function assertLegacyPoolInUse(legacyPath) {
 async function loadAccounts() {
   const path2 = getStoragePath();
   await assertLegacyPoolInUse(path2);
-  await ensureGitignore(dirname11(path2));
+  await ensureGitignore(dirname17(path2));
   return loadAccountStorage(path2);
 }
 
@@ -21107,12 +22345,12 @@ async function startOAuthListener({
   let resolveCallback;
   let rejectCallback;
   let timeoutHandle;
-  const callbackPromise = new Promise((resolve7, reject) => {
+  const callbackPromise = new Promise((resolve13, reject) => {
     resolveCallback = (url) => {
       if (settled) return;
       settled = true;
       if (timeoutHandle) clearTimeout(timeoutHandle);
-      resolve7(url);
+      resolve13(url);
     };
     rejectCallback = (error) => {
       if (settled) return;
@@ -21270,7 +22508,7 @@ async function startOAuthListener({
     });
   });
   const bindAddress = getBindAddress();
-  await new Promise((resolve7, reject) => {
+  await new Promise((resolve13, reject) => {
     const handleError = (error) => {
       server.off("error", handleError);
       if (error.code === "EADDRINUSE") {
@@ -21286,7 +22524,7 @@ async function startOAuthListener({
     server.once("error", handleError);
     server.listen(port, bindAddress, () => {
       server.off("error", handleError);
-      resolve7();
+      resolve13();
     });
   });
   server.on("error", (error) => {
@@ -21294,7 +22532,7 @@ async function startOAuthListener({
   });
   return {
     waitForCallback: () => callbackPromise,
-    close: () => new Promise((resolve7, reject) => {
+    close: () => new Promise((resolve13, reject) => {
       server.close((error) => {
         if (error && error.code !== "ERR_SERVER_NOT_RUNNING") {
           reject(error);
@@ -21303,7 +22541,7 @@ async function startOAuthListener({
         if (!settled) {
           rejectCallback(new Error("OAuth listener closed before callback"));
         }
-        resolve7();
+        resolve13();
       });
     })
   };
@@ -21620,7 +22858,7 @@ function present(value) {
   return value === null ? void 0 : value;
 }
 function cliAccountOf(row) {
-  const metadata = row.metadata.status === "present" ? row.metadata.metadata : void 0;
+  const metadata2 = row.metadata.status === "present" ? row.metadata.metadata : void 0;
   const groups = row.quota.status === "present" ? row.quota.quota.cachedQuota : void 0;
   const cachedQuota = {};
   for (const [name, group] of Object.entries(groups ?? {})) {
@@ -21630,19 +22868,19 @@ function cliAccountOf(row) {
       ...typeof group.resetTime === "string" ? { resetTime: group.resetTime } : {}
     };
   }
-  const email = present(metadata?.email);
-  const projectId = present(metadata?.projectId);
-  const managedProjectId = present(metadata?.managedProjectId);
+  const email = present(metadata2?.email);
+  const projectId = present(metadata2?.projectId);
+  const managedProjectId = present(metadata2?.managedProjectId);
   return {
     refreshToken: row.credential?.refreshToken ?? "",
-    addedAt: metadata?.addedAt ?? row.storeAddedAt ?? 0,
-    lastUsed: metadata?.lastUsed ?? 0,
+    addedAt: metadata2?.addedAt ?? row.storeAddedAt ?? 0,
+    lastUsed: metadata2?.lastUsed ?? 0,
     enabled: row.enabled,
     ...email !== void 0 ? { email } : {},
     ...projectId !== void 0 ? { projectId } : {},
     ...managedProjectId !== void 0 ? { managedProjectId } : {},
-    ...metadata?.verificationRequired === true ? { verificationRequired: true } : {},
-    ...metadata?.accountIneligible === true ? { accountIneligible: true } : {},
+    ...metadata2?.verificationRequired === true ? { verificationRequired: true } : {},
+    ...metadata2?.accountIneligible === true ? { accountIneligible: true } : {},
     ...Object.keys(cachedQuota).length > 0 ? { cachedQuota } : {}
   };
 }
@@ -21692,7 +22930,7 @@ async function readAccountStore(legacyPath) {
 function createDefaultAccountStoreOperations() {
   const offline = { processesStopped: true };
   return {
-    legacyPath: () => resolve6(getStoragePath()),
+    legacyPath: () => resolve12(getStoragePath()),
     migrate: async (legacyPath) => createAccountMigrationFactory(await loadCommonAuthStoreModules())({
       legacyPath,
       offline,