@yansigit/opencodex 2.36.1-dev.20260829.32 → 2.36.1-dev.20260829.34

package/src/generated/compatibility-version.json

@@ -10,7 +10,7 @@
     },
     {
       "path": "package.json",
-      "sha256": "938f15acfdefc9e0d92aa9b59788c73d53d0e8cebd3b2e4a5194ecd1ead2a373"
+      "sha256": "3d5021c8d2ed4fd75d71843af16e27288d71580386a8fb5b6f9d2c2ea2851fb6"
     },
     {
       "path": "scripts/model-metadata.source.json",
@@ -54,7 +54,7 @@
     },
     {
       "path": "src/adapters/command-code-project-context.ts",
-      "sha256": "72bcc19ad2ce2a3f743391d6388c67912e3cf3bfc244dd6b410638c2c34241a5"
+      "sha256": "44c4f2ce44231fb19d7068363b6a13f38c8d7fb7ffd7e049f3c47da967abb7ab"
     },
     {
       "path": "src/adapters/command-code.ts",
@@ -814,7 +814,7 @@
     },
     {
       "path": "src/codex/catalog/sync.ts",
-      "sha256": "ca087dfda6c09914a97aff53a3427e8b56d7e27f9db1e942a435e1fdbaaa4174"
+      "sha256": "f03b4c28e4be29f9df3784d1cb58bc83ca8a58e646d91894b9a90fa339508be4"
     },
     {
       "path": "src/codex/codex-write-lock.ts",
@@ -2166,7 +2166,7 @@
     },
     {
       "path": "src/oauth/google-antigravity.ts",
-      "sha256": "babefb5a2b6648bf97b47e5cb1ceb52c6c03443625f02195175d6c14b8d83bc0"
+      "sha256": "a5546286e647862c4b6be097495e10ec75ba0026f4c20ab8cb277c1d2697893d"
     },
     {
       "path": "src/oauth/health.ts",
@@ -3074,11 +3074,11 @@
     },
     {
       "path": "src/storage/cleanup.ts",
-      "sha256": "57a8a06f9f2a898fa129766124cbbc51596f5c6a650c3ea22b9ba02e139cc20a"
+      "sha256": "2a90e83983c7da9bdb2ac0134870dd7ba85d4469237fae798c60b34985c8e554"
     },
     {
       "path": "src/storage/policy-job.ts",
-      "sha256": "25b014d6b188505ab713640bb9ba223807d33c4258d15450a7b3397adec1f4bc"
+      "sha256": "4fa9f2297feb1a9404af6173adbf875c19f5e79f4b1aca0056744e83d503ad8a"
     },
     {
       "path": "src/storage/policy-scheduler.ts",
@@ -3086,19 +3086,19 @@
     },
     {
       "path": "src/storage/policy-worker.ts",
-      "sha256": "e4637c162efd2f91cf291d9eecc575f71ca8322afa1868146e4a6f387bbaaee7"
+      "sha256": "c33d74fe319fc9103bd1937a81c8f0b23f319d7f634bea87a691da845ebec282"
     },
     {
       "path": "src/storage/policy.ts",
-      "sha256": "64df434d0bc5fb2c9f9ef3cada20c34a439f1bd658a23c251b3b17cdadf4412d"
+      "sha256": "93050c0be848f0df9c7114d903272738fb817b62fb0cdd9d7a59e55b9b267601"
     },
     {
       "path": "src/storage/restore-job.ts",
-      "sha256": "b3bd80c88d96cd79a57fb964f58b3134a00d556e56bac01f5d4718515306048e"
+      "sha256": "216a1a1c3610f5d3fbf50952855b792583f851bc989294f986208c93fd9eefaa"
     },
     {
       "path": "src/storage/restore-worker.ts",
-      "sha256": "a74ecc8a3ef5d1991da15bcb24a60d43c877ee1bd698e65f0ba86d97750bf96d"
+      "sha256": "4ff17868a3e04fd28db86269c17d2e5600cf6e0222374fc3032854cb0990c766"
     },
     {
       "path": "src/storage/scanner.ts",
@@ -3106,7 +3106,7 @@
     },
     {
       "path": "src/storage/storage-mutation-coordinator.ts",
-      "sha256": "b669af88a7c66d1d07b6c4b6cf6111409a07790a74349a22022ffac602832694"
+      "sha256": "65d0560e25f73d6b4bbfb64168cfd37bd796d74781368819207339be254df51b"
     },
     {
       "path": "src/storage/worker-lifecycle.ts",

package/src/oauth/google-antigravity.ts

@@ -37,7 +37,13 @@ const CALLBACK_PATH = "/callback";
 const REFRESH_SKEW_MS = 5 * 60 * 1000;
 const REQUEST_TIMEOUT_MS = 30_000;
 const ONBOARD_ATTEMPTS = 5;
-const ONBOARD_POLL_MS = 2_000;
+const ANTIGRAVITY_ONBOARD_POLL_MS = 2_000;
+const defaultSleep = (ms: number): Promise<void> => new Promise(resolve => setTimeout(resolve, ms));
+let sleepForTests: ((ms: number) => Promise<void>) | undefined;
+
+export function setAntigravityOnboardSleepForTests(sleep: ((ms: number) => Promise<void>) | undefined): void {
+  sleepForTests = sleep;
+}
 
 function requestSignal(signal: AbortSignal | undefined): AbortSignal {
   const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
@@ -136,7 +142,11 @@ async function loadCodeAssistProject(accessToken: string, signal?: AbortSignal):
   return extractProjectId((await response.json().catch(() => undefined)) as Record<string, unknown> | undefined);
 }
 
-async function onboardProject(accessToken: string, signal?: AbortSignal): Promise<string | undefined> {
+async function onboardProject(
+  accessToken: string,
+  signal?: AbortSignal,
+): Promise<string | undefined> {
+  const sleep = sleepForTests ?? defaultSleep;
   for (let attempt = 0; attempt < ONBOARD_ATTEMPTS; attempt++) {
     if (signal?.aborted) throw signal.reason ?? new Error("Antigravity onboarding aborted");
     const response = await fetch(`${DAILY_API}/${API_VERSION}:onboardUser`, {
@@ -153,7 +163,7 @@ async function onboardProject(accessToken: string, signal?: AbortSignal): Promis
     if (!response.ok) {
       // Transient (429/5xx): keep polling within the attempt budget. Hard 4xx: give up now.
       if (response.status === 429 || response.status >= 500) {
-        await new Promise(resolve => setTimeout(resolve, ONBOARD_POLL_MS));
+        await sleep(ANTIGRAVITY_ONBOARD_POLL_MS);
         continue;
       }
       return undefined;
@@ -162,13 +172,16 @@ async function onboardProject(accessToken: string, signal?: AbortSignal): Promis
     if (data.done === true) {
       return extractProjectId(data.response as Record<string, unknown> | undefined);
     }
-    await new Promise(resolve => setTimeout(resolve, ONBOARD_POLL_MS));
+    await sleep(ANTIGRAVITY_ONBOARD_POLL_MS);
   }
   return undefined;
 }
 
 /** Discover the CCA project for an access token (loadCodeAssist → onboardUser fallback). */
-export async function discoverAntigravityProject(accessToken: string, signal?: AbortSignal): Promise<string | undefined> {
+export async function discoverAntigravityProject(
+  accessToken: string,
+  signal?: AbortSignal,
+): Promise<string | undefined> {
   return (await loadCodeAssistProject(accessToken, signal)) ?? (await onboardProject(accessToken, signal));
 }
 

package/src/storage/cleanup.ts

@@ -2578,6 +2578,10 @@ export interface RestoreTestHooks {
    * reconcile, so cleanup can race an in-flight restore.
    */
   holdAfterFileMovesMs?: number;
+  /** Internal test seam: pause after moves until the owner releases it. */
+  waitAfterFileMoves?: SharedArrayBuffer;
+  /** Internal worker-only notification after rollout moves complete. */
+  notifyAfterFileMoves?: boolean;
 }
 
 /**
@@ -2924,6 +2928,13 @@ export function restoreTrashEntry(
       while (Date.now() < deadline) { /* test-only spin wait */ }
     }
   }
+  if (hooks?.waitAfterFileMoves) {
+    if (hooks.notifyAfterFileMoves) {
+      Atomics.store(new Int32Array(hooks.waitAfterFileMoves), 1, 1);
+      Atomics.notify(new Int32Array(hooks.waitAfterFileMoves), 1);
+    }
+    Atomics.wait(new Int32Array(hooks.waitAfterFileMoves), 0, 0);
+  }
 
   if (hooks?.failAfterFileMoves) {
     return abortAfterMoves("fs_failed");

package/src/storage/policy-job.ts

@@ -62,6 +62,14 @@ export interface PolicyJobTestHooks {
    * policy load, so concurrent PUTs can race completion metadata writes.
    */
   blockMs?: number;
+  /** Notify race tests once the shared mutation lease is acquired. */
+  onAcquired?: () => void;
+  /** Notify after the worker has loaded its policy snapshot. */
+  onPolicyLoaded?: () => void;
+  /** Test-only worker gate after the policy snapshot, before metadata save. */
+  waitAfterPolicyLoadedBuffer?: SharedArrayBuffer;
+  /** Keep the policy job at the lease boundary until a competing request is issued. */
+  waitForRelease?: Promise<void>;
   /**
    * When true, run on the main thread via `queueMicrotask` + optional sleep.
    * Used only for unit tests that cannot spawn workers; responsiveness tests
@@ -292,13 +300,14 @@ function applyMutationBusy(): void {
   };
 }
 
-function runInWorker(opts: RequestPolicyRunOptions & { blockMs?: number }): Promise<PolicyRunResult> {
+function runInWorker(opts: RequestPolicyRunOptions & { blockMs?: number; notifyLoaded?: () => void; waitAfterPolicyLoadedBuffer?: SharedArrayBuffer }): Promise<PolicyRunResult> {
   const reservation = tryReserveStorageWorker();
   if (!reservation) return Promise.reject(new StorageWorkerAdmissionBusyError());
   return withStorageWorkerSpawnGate(() => new Promise<PolicyRunResult>((resolve, reject) => {
     const requestId = crypto.randomUUID();
     let settled = false;
     let worker: Worker;
+    const loadedRelease = opts.waitAfterPolicyLoadedBuffer;
     try {
       worker = new Worker(new URL("./policy-worker.ts", import.meta.url).href);
       reservation.bind(worker);
@@ -335,6 +344,10 @@ function runInWorker(opts: RequestPolicyRunOptions & { blockMs?: number }): Prom
       if (!data || typeof data !== "object") return;
       const msg = data as Record<string, unknown>;
       if (msg.requestId !== requestId) return;
+      if (msg.type === "loaded") {
+        opts.notifyLoaded?.();
+        return;
+      }
       if (msg.type === "done" && msg.result && typeof msg.result === "object") {
         finish(() => resolve(msg.result as PolicyRunResult));
         return;
@@ -357,6 +370,9 @@ function runInWorker(opts: RequestPolicyRunOptions & { blockMs?: number }): Prom
       ...(opts.codexHome ? { codexHome: opts.codexHome } : {}),
       ...(opts.busyTimeoutMs !== undefined ? { busyTimeoutMs: opts.busyTimeoutMs } : {}),
       ...(opts.blockMs !== undefined ? { blockMs: opts.blockMs } : {}),
+      ...(opts.notifyLoaded ? { notifyLoaded: true } : {}),
+      ...(loadedRelease ? { waitForLoadedRelease: true } : {}),
+      ...(loadedRelease ? { loadedRelease } : {}),
       env: {
         ...(process.env.CODEX_HOME ? { CODEX_HOME: process.env.CODEX_HOME } : {}),
         ...(process.env.OPENCODEX_HOME ? { OPENCODEX_HOME: process.env.OPENCODEX_HOME } : {}),
@@ -378,8 +394,12 @@ async function executeJob(opts: RequestPolicyRunOptions): Promise<void> {
     }
     return;
   }
-  heldMutationLease = gate.lease;
+  const lease = gate.lease;
+  heldMutationLease = lease;
   try {
+    testHooks?.onAcquired?.();
+    await testHooks?.waitForRelease;
+    if (generation !== runGeneration) return;
     const blockMs = testHooks?.blockMs;
     let result: PolicyRunResult;
 
@@ -392,12 +412,15 @@ async function executeJob(opts: RequestPolicyRunOptions): Promise<void> {
         codexHome,
         ...(opts.busyTimeoutMs !== undefined ? { busyTimeoutMs: opts.busyTimeoutMs } : {}),
         ...(typeof blockMs === "number" && blockMs > 0 ? { holdAfterLoadMs: blockMs } : {}),
+        ...(testHooks?.onPolicyLoaded ? { onPolicyLoaded: testHooks.onPolicyLoaded } : {}),
       });
     } else {
       result = await runInWorker({
         ...opts,
         codexHome,
         ...(typeof blockMs === "number" && blockMs > 0 ? { blockMs } : {}),
+        ...(testHooks?.onPolicyLoaded ? { notifyLoaded: testHooks.onPolicyLoaded } : {}),
+        ...(testHooks?.waitAfterPolicyLoadedBuffer ? { waitAfterPolicyLoadedBuffer: testHooks.waitAfterPolicyLoadedBuffer } : {}),
       });
     }
 
@@ -408,7 +431,10 @@ async function executeJob(opts: RequestPolicyRunOptions): Promise<void> {
     if (err instanceof StorageWorkerAdmissionBusyError) applyMutationBusy();
     else applyFailed(err instanceof Error ? err.message : "worker_failed");
   } finally {
-    releaseHeldMutationSlot();
+    // A reset may let a newer run acquire the global mirror before this stale
+    // continuation resumes. Release only the lease captured by this run.
+    lease.release();
+    if (heldMutationLease === lease) heldMutationLease = undefined;
   }
 }
 

package/src/storage/policy-worker.ts

@@ -13,6 +13,9 @@ interface RunMessage {
   busyTimeoutMs?: number;
   /** Test-only: block after loading the start-of-job policy (see holdAfterLoadMs). */
   blockMs?: number;
+  notifyLoaded?: boolean;
+  waitForLoadedRelease?: boolean;
+  loadedRelease?: SharedArrayBuffer;
   /** Env snapshot — Workers may not see parent mutations on all platforms. */
   env?: { CODEX_HOME?: string; OPENCODEX_HOME?: string };
 }
@@ -29,7 +32,7 @@ declare const self: Worker;
 
 self.onmessage = (event: MessageEvent<unknown>) => {
   if (!isRunMessage(event.data)) return;
-  const { requestId, reason, force, codexHome, busyTimeoutMs, blockMs, env } = event.data;
+  const { requestId, reason, force, codexHome, busyTimeoutMs, blockMs, notifyLoaded, waitForLoadedRelease, loadedRelease, env } = event.data;
   try {
     if (env?.CODEX_HOME) process.env.CODEX_HOME = env.CODEX_HOME;
     if (env?.OPENCODEX_HOME) process.env.OPENCODEX_HOME = env.OPENCODEX_HOME;
@@ -38,6 +41,10 @@ self.onmessage = (event: MessageEvent<unknown>) => {
       force: force === true,
       ...(codexHome ? { codexHome } : {}),
       ...(busyTimeoutMs !== undefined ? { busyTimeoutMs } : {}),
+      ...(notifyLoaded ? { onPolicyLoaded: () => {
+        self.postMessage({ type: "loaded", requestId });
+        if (waitForLoadedRelease && loadedRelease) Atomics.wait(new Int32Array(loadedRelease), 0, 0);
+      } } : {}),
       ...(typeof blockMs === "number" && Number.isFinite(blockMs) && blockMs > 0
         ? { holdAfterLoadMs: Math.floor(blockMs) }
         : {}),

package/src/storage/policy.ts

@@ -72,6 +72,8 @@ export interface PolicyRunDeps {
    * land before completion merges run metadata.
    */
   holdAfterLoadMs?: number;
+  /** Test-only synchronization seam; omitted in production. */
+  onPolicyLoaded?: () => void;
 }
 
 /** Canonical defaults — enabled is always false. */
@@ -436,6 +438,7 @@ export function runStorageCleanupPolicy(deps: PolicyRunDeps): PolicyRunResult {
   const execute = deps.execute ?? executeArchivedCleanup;
 
   const policy = normalizeStorageCleanupPolicy(load());
+  deps.onPolicyLoaded?.();
 
   if (typeof deps.holdAfterLoadMs === "number" && Number.isFinite(deps.holdAfterLoadMs) && deps.holdAfterLoadMs > 0) {
     Bun.sleepSync(Math.floor(deps.holdAfterLoadMs));

package/src/storage/restore-job.ts

@@ -35,6 +35,8 @@ export interface RestoreJobTestHooks extends StorageMutationCoordinatorTestHooks
   enableTestStream?: boolean;
   /** Forwarded to restoreTrashEntry _test hooks. */
   restoreTest?: RestoreTestHooks;
+  /** Notify responsiveness tests once the worker is about to block. */
+  workerReady?: SharedArrayBuffer;
 }
 
 const WORKER_TIMEOUT_MS = 10 * 60 * 1000;
@@ -159,6 +161,7 @@ function runInWorker(opts: {
   busyTimeoutMs?: number;
   blockMs?: number;
   restoreTest?: RestoreTestHooks;
+  workerReady?: SharedArrayBuffer;
 }): Promise<RestoreResult> {
   const reservation = tryReserveStorageWorker();
   if (!reservation) return Promise.reject(new StorageWorkerAdmissionBusyError());
@@ -222,6 +225,7 @@ function runInWorker(opts: {
       ...(opts.busyTimeoutMs !== undefined ? { busyTimeoutMs: opts.busyTimeoutMs } : {}),
       ...(opts.blockMs !== undefined ? { blockMs: opts.blockMs } : {}),
       ...(opts.restoreTest ? { restoreTest: opts.restoreTest } : {}),
+      ...(opts.workerReady ? { workerReady: opts.workerReady } : {}),
       env: {
         ...(process.env.CODEX_HOME ? { CODEX_HOME: process.env.CODEX_HOME } : {}),
         ...(process.env.OPENCODEX_HOME ? { OPENCODEX_HOME: process.env.OPENCODEX_HOME } : {}),
@@ -258,6 +262,7 @@ async function executeRestore(opts: {
       ...(opts.busyTimeoutMs !== undefined ? { busyTimeoutMs: opts.busyTimeoutMs } : {}),
       ...(typeof blockMs === "number" && blockMs > 0 ? { blockMs } : {}),
       ...(restoreTest ? { restoreTest } : {}),
+      ...(testHooks?.workerReady ? { workerReady: testHooks.workerReady } : {}),
     });
   } catch (err) {
     if (err instanceof StorageWorkerAdmissionBusyError) return busyRestoreResult();

package/src/storage/restore-worker.ts

@@ -13,6 +13,7 @@ interface RunMessage {
   /** Test-only: block before restore so responsiveness tests can probe /healthz. */
   blockMs?: number;
   restoreTest?: RestoreTestHooks;
+  workerReady?: SharedArrayBuffer;
   /** Env snapshot — Workers may not see parent mutations on all platforms. */
   env?: { CODEX_HOME?: string; OPENCODEX_HOME?: string };
 }
@@ -27,11 +28,16 @@ declare const self: Worker;
 
 self.onmessage = async (event: MessageEvent<unknown>) => {
   if (!isRunMessage(event.data)) return;
-  const { requestId, trashId, codexHome, busyTimeoutMs, blockMs, restoreTest, env } = event.data;
+  const { requestId, trashId, codexHome, busyTimeoutMs, blockMs, restoreTest, workerReady, env } = event.data;
   try {
     if (env?.CODEX_HOME) process.env.CODEX_HOME = env.CODEX_HOME;
     if (env?.OPENCODEX_HOME) process.env.OPENCODEX_HOME = env.OPENCODEX_HOME;
     if (typeof blockMs === "number" && Number.isFinite(blockMs) && blockMs > 0) {
+      if (workerReady) {
+        const ready = new Int32Array(workerReady);
+        Atomics.store(ready, 0, 1);
+        Atomics.notify(ready, 0);
+      }
       await Bun.sleep(Math.floor(blockMs));
     }
     const result = restoreTrashEntry(trashId, {

package/src/storage/storage-mutation-coordinator.ts

@@ -16,6 +16,10 @@ export type StorageMutationBusyError = "storage_mutation_busy";
 export interface StorageMutationCoordinatorTestHooks {
   /** Block after acquiring the slot, before mutation work (race tests). */
   blockMs?: number;
+  /** Notify race tests as soon as the per-home lease is owned. */
+  onAcquired?: () => void;
+  /** Keep the lease held until a race test has issued its competing operation. */
+  waitForRelease?: Promise<void>;
 }
 
 interface ActiveSlot {
@@ -79,6 +83,7 @@ export function tryBeginStorageMutation(
     },
   };
   slots.set(key, { kind, startedAt: Date.now(), lease: ownerLease });
+  testHooks?.onAcquired?.();
   return { acquired: true, lease: ownerLease };
 }
 
@@ -94,6 +99,7 @@ export function endStorageMutation(codexHome?: string): void {
 }
 
 async function applyCoordinatorBlock(): Promise<void> {
+  await testHooks?.waitForRelease;
   const blockMs = testHooks?.blockMs;
   if (typeof blockMs === "number" && Number.isFinite(blockMs) && blockMs > 0) {
     await Bun.sleep(Math.floor(blockMs));