@abot-ai/runtime 1.6.0 → 1.8.0

package/plugins/memory/plugin.json

@@ -4,6 +4,10 @@
   "version": "1.0.0",
   "description": "Read, search, add, and delete deterministic long-term memory entries.",
   "extensions": {
+    "ai.abot.compatibility": {
+      "version": 1,
+      "runtimePlatforms": ["linux", "darwin", "win32"]
+    },
     "ai.abot.runtime": {
       "version": 1,
       "entrypoint": "./src/index.cjs",

package/plugins/memory/source/lock-directory-claim.ts

@@ -0,0 +1,56 @@
+import type { BigIntStats } from "node:fs";
+import { lstat, mkdir } from "node:fs/promises";
+
+import { isWindowsLockObservationDenial } from "./lock-path-observation.js";
+
+type LockClaimObservation = Readonly<{
+  observed: boolean;
+  entry?: BigIntStats;
+}>;
+
+function isAbsentLockClaimEntry(error: unknown): boolean {
+  if (!error || typeof error !== "object" || !("code" in error)) return false;
+  return error.code === "ENOENT";
+}
+
+async function observeLockClaimPath(path: string): Promise<LockClaimObservation> {
+  try {
+    return { observed: true, entry: await lstat(path, { bigint: true }) };
+  } catch (error) {
+    return { observed: isAbsentLockClaimEntry(error) };
+  }
+}
+
+function hasObservedLockNameTransition(
+  before: LockClaimObservation,
+  after: LockClaimObservation,
+): boolean {
+  if (!before.observed || !after.observed) return false;
+  if (!before.entry) return after.entry !== undefined;
+  if (!after.entry) return true;
+  if (before.entry.dev !== after.entry.dev) return true;
+  if (before.entry.ino !== after.entry.ino) return true;
+  if (before.entry.isDirectory() !== after.entry.isDirectory()) return true;
+  if (before.entry.isFile() !== after.entry.isFile()) return true;
+  return before.entry.isSymbolicLink() !== after.entry.isSymbolicLink();
+}
+
+/** Successful mkdir alone grants ownership; a proven name race is contention. */
+export async function claimStoreLockDirectory(path: string): Promise<void> {
+  if (process.platform !== "win32") {
+    await mkdir(path, { mode: 0o700 });
+    return;
+  }
+  const before = await observeLockClaimPath(path);
+  try {
+    await mkdir(path, { mode: 0o700 });
+  } catch (error) {
+    if (!isWindowsLockObservationDenial(error)) throw error;
+    const after = await observeLockClaimPath(path);
+    if (!hasObservedLockNameTransition(before, after)) throw error;
+    throw Object.assign(new Error("Memory lock name changed during its directory claim."), {
+      code: "EEXIST",
+      cause: error,
+    });
+  }
+}

package/plugins/memory/source/lock-owner-file.ts

@@ -0,0 +1,71 @@
+import { constants, type BigIntStats } from "node:fs";
+import { lstat, open, type FileHandle } from "node:fs/promises";
+
+import {
+  isWindowsLockObservationDenial,
+  rethrowLockObservationError,
+} from "./lock-path-observation.js";
+
+function lockOwnerOpenError(code: "ELOOP" | "EAGAIN"): Error {
+  return Object.assign(new Error("Memory lock owner is not a stable regular file."), {
+    code,
+  });
+}
+
+function hasSameRegularOwnerIdentity(
+  before: BigIntStats,
+  current: BigIntStats,
+): boolean {
+  if (!current.isFile()) return false;
+  if (current.dev !== before.dev) return false;
+  return current.ino === before.ino;
+}
+
+async function openObservedLockOwner(
+  path: string,
+  flags: number,
+  before: BigIntStats,
+): Promise<FileHandle> {
+  try {
+    return await open(path, flags);
+  } catch (error) {
+    if (!isWindowsLockObservationDenial(error)) throw error;
+    // Windows can report a pending deletion as EPERM. Only a fresh name
+    // observation may classify it as a vanished or replaced owner.
+    const named = await lstat(path, { bigint: true });
+    if (!hasSameRegularOwnerIdentity(before, named)) {
+      throw lockOwnerOpenError("EAGAIN");
+    }
+    throw error;
+  }
+}
+
+/**
+ * Preserve atomic no-follow where Node supports it. On Windows, verify the
+ * named regular file and opened handle before accepting any owner record.
+ * This guards lock ownership; it is not a general filesystem sandbox.
+ */
+export async function openLockOwnerFile(path: string): Promise<FileHandle> {
+  const before = await lstat(path, { bigint: true });
+  if (!before.isFile()) throw lockOwnerOpenError("ELOOP");
+  const noFollow = constants.O_NOFOLLOW;
+  const flags = typeof noFollow === "number"
+    ? constants.O_RDONLY | noFollow
+    : constants.O_RDONLY;
+  const handle = await openObservedLockOwner(path, flags, before);
+  try {
+    const opened = await handle.stat({ bigint: true });
+    const named = await lstat(path, { bigint: true });
+    if (!hasSameRegularOwnerIdentity(before, opened)) {
+      throw lockOwnerOpenError("EAGAIN");
+    }
+    if (!hasSameRegularOwnerIdentity(before, named)) {
+      throw lockOwnerOpenError("EAGAIN");
+    }
+    return handle;
+  } catch (error) {
+    await handle.close().catch(() => undefined);
+    // Closing our handle can complete a Windows pending deletion.
+    return rethrowLockObservationError(path, error);
+  }
+}

package/plugins/memory/source/lock-path-observation.ts

@@ -0,0 +1,26 @@
+import { lstat } from "node:fs/promises";
+
+export function isWindowsLockObservationDenial(error: unknown): boolean {
+  if (process.platform !== "win32") return false;
+  if (!error || typeof error !== "object" || !("code" in error)) return false;
+  return error.code === "EPERM";
+}
+
+function isMissingLockObservation(error: unknown): boolean {
+  if (!error || typeof error !== "object" || !("code" in error)) return false;
+  return error.code === "ENOENT";
+}
+
+/** Normalize only a freshly confirmed disappearance; never accept opaque locks. */
+export async function rethrowLockObservationError(
+  path: string,
+  error: unknown,
+): Promise<never> {
+  if (!isWindowsLockObservationDenial(error)) throw error;
+  try {
+    await lstat(path);
+  } catch (observationError) {
+    if (isMissingLockObservation(observationError)) throw observationError;
+  }
+  throw error;
+}

package/plugins/memory/source/prepared-memory-replacement.ts

@@ -0,0 +1,40 @@
+import { rename } from "node:fs/promises";
+import { performance } from "node:perf_hooks";
+
+const WINDOWS_REPLACEMENT_WAIT_MS = 1_000;
+const WINDOWS_REPLACEMENT_DELAY_MS = 25;
+const MAX_REPLACEMENT_ATTEMPTS = 41;
+
+function isRetryableWindowsMemoryReplacementError(error: unknown): boolean {
+  if (process.platform !== "win32") return false;
+  if (error === null || typeof error !== "object") return false;
+  return "code" in error && error.code === "EPERM";
+}
+
+function canWaitForMemoryReplacement(attempts: number, deadline: number): boolean {
+  if (attempts >= MAX_REPLACEMENT_ATTEMPTS) return false;
+  return performance.now() < deadline;
+}
+
+/**
+ * Readers can temporarily deny Windows replacement. Permanent EPERM stays an error.
+ * The caller keeps the mutation lock and owns cleanup; never rerun the mutation.
+ */
+export async function replacePreparedMemoryFile(temporary: string, target: string): Promise<void> {
+  const deadline = performance.now() + WINDOWS_REPLACEMENT_WAIT_MS;
+  let attempts = 0;
+  for (;;) {
+    attempts += 1;
+    try {
+      await rename(temporary, target);
+      return;
+    } catch (error) {
+      if (!isRetryableWindowsMemoryReplacementError(error)) throw error;
+      if (!canWaitForMemoryReplacement(attempts, deadline)) throw error;
+      const delayMs = Math.min(WINDOWS_REPLACEMENT_DELAY_MS, deadline - performance.now());
+      await new Promise<void>((resolve) => setTimeout(resolve, Math.max(0, delayMs)));
+      // A late timer must not start another attempt beyond the monotonic deadline.
+      if (performance.now() >= deadline) throw error;
+    }
+  }
+}

package/plugins/memory/source/store-lock.ts

@@ -1,5 +1,4 @@
 import { randomUUID } from "node:crypto";
-import { constants } from "node:fs";
 import {
   lstat,
   mkdir,
@@ -13,6 +12,9 @@ import {
 import { dirname, join } from "node:path";
 
 import { MemoryStoreError } from "./types.js";
+import { openLockOwnerFile } from "./lock-owner-file.js";
+import { rethrowLockObservationError } from "./lock-path-observation.js";
+import { claimStoreLockDirectory } from "./lock-directory-claim.js";
 
 const DEFAULT_WAIT_MS = 10_000;
 const DEFAULT_RETRY_MS = 10;
@@ -112,9 +114,8 @@ async function readOwnerRecord(
 ): Promise<DirectoryLockSnapshot> {
   let handle: FileHandle | undefined;
   try {
-    handle = await open(
+    handle = await openLockOwnerFile(
       join(lockPath, LEASE_DIRECTORY_NAME, entryName),
-      constants.O_RDONLY | constants.O_NOFOLLOW,
     );
     const info = await handle.stat({ bigint: true });
     const modifiedAtMs = Math.max(directoryModifiedAtMs, Number(info.mtimeMs));
@@ -179,7 +180,7 @@ async function readOwnerRecord(
     });
   } catch (error) {
     const code = fileSystemErrorCode(error);
-    if (code === "ENOENT") {
+    if (code === "ENOENT" || code === "EAGAIN") {
       return Object.freeze({
         kind: "directory",
         modifiedAtMs: directoryModifiedAtMs,
@@ -218,7 +219,9 @@ async function readLockSnapshot(
 
   let entries;
   try {
-    entries = await readdir(lockPath, { withFileTypes: true });
+    entries = await readdir(lockPath, { withFileTypes: true }).catch(
+      (error) => rethrowLockObservationError(lockPath, error),
+    );
   } catch (error) {
     const code = fileSystemErrorCode(error);
     if (code === "ENOENT") return undefined;
@@ -259,7 +262,9 @@ async function readLockSnapshot(
         reclaimable: false,
       });
     }
-    leaseEntries = await readdir(leasePath, { withFileTypes: true });
+    leaseEntries = await readdir(leasePath, { withFileTypes: true }).catch(
+      (error) => rethrowLockObservationError(leasePath, error),
+    );
   } catch (error) {
     const code = fileSystemErrorCode(error);
     if (code === "ENOENT") {
@@ -417,7 +422,7 @@ async function installLockDirectory(
     await handle.sync();
     await handle.close();
     handle = undefined;
-    await mkdir(lockPath, { mode: 0o700 });
+    await claimStoreLockDirectory(lockPath);
     claimedLockPath = true;
     await rename(stagingPath, join(lockPath, LEASE_DIRECTORY_NAME));
     installed = true;

package/plugins/memory/source/store.ts

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { access, mkdir, open, rename, rm, writeFile } from "node:fs/promises";
+import { access, mkdir, open, rm, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 
 import {
@@ -8,6 +8,7 @@ import {
   type MemoryStoreState,
 } from "./types.js";
 import { acquireStoreLock } from "./store-lock.js";
+import { replacePreparedMemoryFile } from "./prepared-memory-replacement.js";
 
 const MAX_STORE_BYTES = 4 * 1024 * 1024;
 const MAX_STORE_ENTRIES = 2_000;
@@ -133,7 +134,7 @@ async function atomicWrite(
       encoding: "utf8",
       mode: 0o600,
     });
-    await rename(temporaryPath, filePath);
+    await replacePreparedMemoryFile(temporaryPath, filePath);
   } finally {
     await rm(temporaryPath, { force: true });
   }

package/plugins/memory/src/index.cjs

@@ -311,7 +311,7 @@ function searchMemory(entries, query, maximum) {
 
 // plugins/memory/source/store.ts
 var import_node_crypto2 = require("node:crypto");
-var import_promises2 = require("node:fs/promises");
+var import_promises6 = require("node:fs/promises");
 var import_node_path2 = require("node:path");
 
 // plugins/memory/source/types.ts
@@ -329,9 +329,122 @@ function isMemoryStoreError(error) {
 
 // plugins/memory/source/store-lock.ts
 var import_node_crypto = require("node:crypto");
+var import_promises4 = require("node:fs/promises");
+var import_node_path = require("node:path");
+
+// plugins/memory/source/lock-owner-file.ts
 var import_node_fs = require("node:fs");
+var import_promises2 = require("node:fs/promises");
+
+// plugins/memory/source/lock-path-observation.ts
 var import_promises = require("node:fs/promises");
-var import_node_path = require("node:path");
+function isWindowsLockObservationDenial(error) {
+  if (process.platform !== "win32") return false;
+  if (!error || typeof error !== "object" || !("code" in error)) return false;
+  return error.code === "EPERM";
+}
+function isMissingLockObservation(error) {
+  if (!error || typeof error !== "object" || !("code" in error)) return false;
+  return error.code === "ENOENT";
+}
+async function rethrowLockObservationError(path, error) {
+  if (!isWindowsLockObservationDenial(error)) throw error;
+  try {
+    await (0, import_promises.lstat)(path);
+  } catch (observationError) {
+    if (isMissingLockObservation(observationError)) throw observationError;
+  }
+  throw error;
+}
+
+// plugins/memory/source/lock-owner-file.ts
+function lockOwnerOpenError(code) {
+  return Object.assign(new Error("Memory lock owner is not a stable regular file."), {
+    code
+  });
+}
+function hasSameRegularOwnerIdentity(before, current) {
+  if (!current.isFile()) return false;
+  if (current.dev !== before.dev) return false;
+  return current.ino === before.ino;
+}
+async function openObservedLockOwner(path, flags, before) {
+  try {
+    return await (0, import_promises2.open)(path, flags);
+  } catch (error) {
+    if (!isWindowsLockObservationDenial(error)) throw error;
+    const named = await (0, import_promises2.lstat)(path, { bigint: true });
+    if (!hasSameRegularOwnerIdentity(before, named)) {
+      throw lockOwnerOpenError("EAGAIN");
+    }
+    throw error;
+  }
+}
+async function openLockOwnerFile(path) {
+  const before = await (0, import_promises2.lstat)(path, { bigint: true });
+  if (!before.isFile()) throw lockOwnerOpenError("ELOOP");
+  const noFollow = import_node_fs.constants.O_NOFOLLOW;
+  const flags = typeof noFollow === "number" ? import_node_fs.constants.O_RDONLY | noFollow : import_node_fs.constants.O_RDONLY;
+  const handle = await openObservedLockOwner(path, flags, before);
+  try {
+    const opened = await handle.stat({ bigint: true });
+    const named = await (0, import_promises2.lstat)(path, { bigint: true });
+    if (!hasSameRegularOwnerIdentity(before, opened)) {
+      throw lockOwnerOpenError("EAGAIN");
+    }
+    if (!hasSameRegularOwnerIdentity(before, named)) {
+      throw lockOwnerOpenError("EAGAIN");
+    }
+    return handle;
+  } catch (error) {
+    await handle.close().catch(() => void 0);
+    return rethrowLockObservationError(path, error);
+  }
+}
+
+// plugins/memory/source/lock-directory-claim.ts
+var import_promises3 = require("node:fs/promises");
+function isAbsentLockClaimEntry(error) {
+  if (!error || typeof error !== "object" || !("code" in error)) return false;
+  return error.code === "ENOENT";
+}
+async function observeLockClaimPath(path) {
+  try {
+    return { observed: true, entry: await (0, import_promises3.lstat)(path, { bigint: true }) };
+  } catch (error) {
+    return { observed: isAbsentLockClaimEntry(error) };
+  }
+}
+function hasObservedLockNameTransition(before, after) {
+  if (!before.observed || !after.observed) return false;
+  if (!before.entry) return after.entry !== void 0;
+  if (!after.entry) return true;
+  if (before.entry.dev !== after.entry.dev) return true;
+  if (before.entry.ino !== after.entry.ino) return true;
+  if (before.entry.isDirectory() !== after.entry.isDirectory()) return true;
+  if (before.entry.isFile() !== after.entry.isFile()) return true;
+  return before.entry.isSymbolicLink() !== after.entry.isSymbolicLink();
+}
+async function claimStoreLockDirectory(path) {
+  if (process.platform !== "win32") {
+    await (0, import_promises3.mkdir)(path, { mode: 448 });
+    return;
+  }
+  const before = await observeLockClaimPath(path);
+  try {
+    await (0, import_promises3.mkdir)(path, { mode: 448 });
+  } catch (error) {
+    if (!isWindowsLockObservationDenial(error)) throw error;
+    const after = await observeLockClaimPath(path);
+    if (!hasObservedLockNameTransition(before, after)) throw error;
+    throw Object.assign(new Error("Memory lock name changed during its directory claim."), {
+      code: "EEXIST",
+      cause: error
+    });
+  }
+}
+
+// plugins/memory/source/store-lock.ts
 var DEFAULT_WAIT_MS = 1e4;
 var DEFAULT_RETRY_MS = 10;
 var MAX_LOCK_BYTES = 1024;
@@ -379,9 +492,8 @@ function parseLockContents(raw, expectedToken) {
 async function readOwnerRecord(lockPath, entryName, expectedToken, directoryModifiedAtMs) {
   let handle;
   try {
-    handle = await (0, import_promises.open)(
-      (0, import_node_path.join)(lockPath, LEASE_DIRECTORY_NAME, entryName),
-      import_node_fs.constants.O_RDONLY | import_node_fs.constants.O_NOFOLLOW
+    handle = await openLockOwnerFile(
+      (0, import_node_path.join)(lockPath, LEASE_DIRECTORY_NAME, entryName)
     );
     const info = await handle.stat({ bigint: true });
     const modifiedAtMs = Math.max(directoryModifiedAtMs, Number(info.mtimeMs));
@@ -435,7 +547,7 @@ async function readOwnerRecord(lockPath, entryName, expectedToken, directoryModi
     });
   } catch (error) {
     const code = fileSystemErrorCode(error);
-    if (code === "ENOENT") {
+    if (code === "ENOENT" || code === "EAGAIN") {
       return Object.freeze({
         kind: "directory",
         modifiedAtMs: directoryModifiedAtMs,
@@ -460,7 +572,7 @@ async function readOwnerRecord(lockPath, entryName, expectedToken, directoryModi
 async function readLockSnapshot(lockPath) {
   let lockInfo;
   try {
-    lockInfo = await (0, import_promises.lstat)(lockPath);
+    lockInfo = await (0, import_promises4.lstat)(lockPath);
   } catch (error) {
     if (fileSystemErrorCode(error) === "ENOENT") return void 0;
     throw error;
@@ -470,7 +582,9 @@ async function readLockSnapshot(lockPath) {
   }
   let entries;
   try {
-    entries = await (0, import_promises.readdir)(lockPath, { withFileTypes: true });
+    entries = await (0, import_promises4.readdir)(lockPath, { withFileTypes: true }).catch(
+      (error) => rethrowLockObservationError(lockPath, error)
+    );
   } catch (error) {
     const code = fileSystemErrorCode(error);
     if (code === "ENOENT") return void 0;
@@ -497,7 +611,7 @@ async function readLockSnapshot(lockPath) {
   let leaseInfo;
   let leaseEntries;
   try {
-    leaseInfo = await (0, import_promises.lstat)(leasePath);
+    leaseInfo = await (0, import_promises4.lstat)(leasePath);
     if (!leaseInfo.isDirectory()) {
       return Object.freeze({
         kind: "directory",
@@ -506,7 +620,9 @@ async function readLockSnapshot(lockPath) {
         reclaimable: false
       });
     }
-    leaseEntries = await (0, import_promises.readdir)(leasePath, { withFileTypes: true });
+    leaseEntries = await (0, import_promises4.readdir)(leasePath, { withFileTypes: true }).catch(
+      (error) => rethrowLockObservationError(leasePath, error)
+    );
   } catch (error) {
     const code = fileSystemErrorCode(error);
     if (code === "ENOENT") {
@@ -550,7 +666,7 @@ async function readLockSnapshot(lockPath) {
 }
 async function removeDirectoryIfEmpty(path) {
   try {
-    await (0, import_promises.rmdir)(path);
+    await (0, import_promises4.rmdir)(path);
     return true;
   } catch (error) {
     const code = fileSystemErrorCode(error);
@@ -569,7 +685,7 @@ async function removeEmptyLockTree(lockPath, hasLeaseDirectory) {
 }
 async function removeObservedOwner(lockPath, observedOwnerFileName) {
   try {
-    await (0, import_promises.unlink)((0, import_node_path.join)(lockPath, LEASE_DIRECTORY_NAME, observedOwnerFileName));
+    await (0, import_promises4.unlink)((0, import_node_path.join)(lockPath, LEASE_DIRECTORY_NAME, observedOwnerFileName));
   } catch (error) {
     if (fileSystemErrorCode(error) === "ENOENT") return false;
     throw error;
@@ -603,12 +719,12 @@ function isLockConflict(error) {
 }
 async function removeStagingLock(stagingPath, stagingOwnerPath) {
   try {
-    await (0, import_promises.unlink)(stagingOwnerPath);
+    await (0, import_promises4.unlink)(stagingOwnerPath);
   } catch (error) {
     if (fileSystemErrorCode(error) !== "ENOENT") throw error;
   }
   try {
-    await (0, import_promises.rmdir)(stagingPath);
+    await (0, import_promises4.rmdir)(stagingPath);
   } catch (error) {
     if (fileSystemErrorCode(error) !== "ENOENT") throw error;
   }
@@ -620,8 +736,8 @@ async function installLockDirectory(lockPath, token) {
   let installed = false;
   let claimedLockPath = false;
   try {
-    await (0, import_promises.mkdir)(stagingPath, { mode: 448 });
-    handle = await (0, import_promises.open)(stagingOwnerPath, "wx", 384);
+    await (0, import_promises4.mkdir)(stagingPath, { mode: 448 });
+    handle = await (0, import_promises4.open)(stagingOwnerPath, "wx", 384);
     await handle.writeFile(
       JSON.stringify({
         pid: process.pid,
@@ -633,9 +749,9 @@ async function installLockDirectory(lockPath, token) {
     await handle.sync();
     await handle.close();
     handle = void 0;
-    await (0, import_promises.mkdir)(lockPath, { mode: 448 });
+    await claimStoreLockDirectory(lockPath);
     claimedLockPath = true;
-    await (0, import_promises.rename)(stagingPath, (0, import_node_path.join)(lockPath, LEASE_DIRECTORY_NAME));
+    await (0, import_promises4.rename)(stagingPath, (0, import_node_path.join)(lockPath, LEASE_DIRECTORY_NAME));
     installed = true;
   } finally {
     await handle?.close().catch(() => void 0);
@@ -653,7 +769,7 @@ async function acquireStoreLock(filePath, options = {}) {
   const retryMs = options.retryMs ?? DEFAULT_RETRY_MS;
   const processIsAlive = options.processIsAlive ?? defaultProcessIsAlive;
   const deadline = Date.now() + waitMs;
-  await (0, import_promises.mkdir)((0, import_node_path.dirname)(filePath), { recursive: true });
+  await (0, import_promises4.mkdir)((0, import_node_path.dirname)(filePath), { recursive: true });
   while (true) {
     const token = (0, import_node_crypto.randomUUID)();
     try {
@@ -692,6 +808,39 @@ async function acquireStoreLock(filePath, options = {}) {
   }
 }
 
+// plugins/memory/source/prepared-memory-replacement.ts
+var import_promises5 = require("node:fs/promises");
+var import_node_perf_hooks = require("node:perf_hooks");
+var WINDOWS_REPLACEMENT_WAIT_MS = 1e3;
+var WINDOWS_REPLACEMENT_DELAY_MS = 25;
+var MAX_REPLACEMENT_ATTEMPTS = 41;
+function isRetryableWindowsMemoryReplacementError(error) {
+  if (process.platform !== "win32") return false;
+  if (error === null || typeof error !== "object") return false;
+  return "code" in error && error.code === "EPERM";
+}
+function canWaitForMemoryReplacement(attempts, deadline) {
+  if (attempts >= MAX_REPLACEMENT_ATTEMPTS) return false;
+  return import_node_perf_hooks.performance.now() < deadline;
+}
+async function replacePreparedMemoryFile(temporary, target) {
+  const deadline = import_node_perf_hooks.performance.now() + WINDOWS_REPLACEMENT_WAIT_MS;
+  let attempts = 0;
+  for (; ; ) {
+    attempts += 1;
+    try {
+      await (0, import_promises5.rename)(temporary, target);
+      return;
+    } catch (error) {
+      if (!isRetryableWindowsMemoryReplacementError(error)) throw error;
+      if (!canWaitForMemoryReplacement(attempts, deadline)) throw error;
+      const delayMs = Math.min(WINDOWS_REPLACEMENT_DELAY_MS, deadline - import_node_perf_hooks.performance.now());
+      await new Promise((resolve) => setTimeout(resolve, Math.max(0, delayMs)));
+      if (import_node_perf_hooks.performance.now() >= deadline) throw error;
+    }
+  }
+}
+
 // plugins/memory/source/store.ts
 var MAX_STORE_BYTES = 4 * 1024 * 1024;
 var MAX_STORE_ENTRIES = 2e3;
@@ -792,13 +941,13 @@ async function atomicWrite(filePath, state) {
     );
   }
   try {
-    await (0, import_promises2.writeFile)(temporaryPath, serialized, {
+    await (0, import_promises6.writeFile)(temporaryPath, serialized, {
       encoding: "utf8",
       mode: 384
     });
-    await (0, import_promises2.rename)(temporaryPath, filePath);
+    await replacePreparedMemoryFile(temporaryPath, filePath);
   } finally {
-    await (0, import_promises2.rm)(temporaryPath, { force: true });
+    await (0, import_promises6.rm)(temporaryPath, { force: true });
   }
 }
 function nextSequenceAfter(entries) {
@@ -818,7 +967,7 @@ function fileSystemErrorCode2(error) {
   return error && typeof error === "object" && "code" in error ? String(error.code) : void 0;
 }
 async function readStoreFile(filePath) {
-  const handle = await (0, import_promises2.open)(filePath, "r");
+  const handle = await (0, import_promises6.open)(filePath, "r");
   try {
     const info = await handle.stat();
     if (!info.isFile()) {
@@ -869,9 +1018,9 @@ var MemoryStore = class {
     return initialization;
   }
   async #initialize() {
-    await (0, import_promises2.mkdir)((0, import_node_path2.dirname)(this.#filePath), { recursive: true });
+    await (0, import_promises6.mkdir)((0, import_node_path2.dirname)(this.#filePath), { recursive: true });
     try {
-      await (0, import_promises2.access)(this.#filePath);
+      await (0, import_promises6.access)(this.#filePath);
       return;
     } catch (error) {
       if (fileSystemErrorCode2(error) !== "ENOENT") {

package/plugins/project-orientation/README.md

@@ -0,0 +1,23 @@
+# Project Orientation
+
+Inspects a bounded directory tree and project manifest metadata on Linux, macOS
+and native Windows. Relative paths use the configured agent work directory;
+`workspace/...` selects configured workspace sources. Absolute paths retain
+the same authorization boundary, including request-specific restrictions.
+
+Package metadata uses the SDK's bounded reader (256 KiB maximum). Other known
+manifest names are detected without reading their contents. Inspection never
+executes package scripts or changes project files. Existing depth, entry,
+script-name and output limits apply on every platform.
+
+## Windows requirements
+
+Built-in Windows PowerShell and its C# helper provide safe package-manifest
+reading. No Companion, WSL, Docker, elevation or policy bypass is needed.
+If the helper is blocked, `project_safe_read_unavailable` tells the model not
+to retry or bypass the restriction. Cancellation stops the manifest read and
+directory traversal.
+
+A project without `package.json` can still be inspected without starting
+the file-reading helper. Junctions or traversal outside the configured roots
+are rejected by the same Runtime path resolver.

package/plugins/project-orientation/plugin.json

@@ -4,6 +4,7 @@
   "version": "0.3.1",
   "description": "Inspect a bounded project tree and its manifest metadata.",
   "extensions": {
+    "ai.abot.compatibility": { "version": 1, "runtimePlatforms": ["linux", "darwin", "win32"] },
     "ai.abot.runtime": {
       "version": 1,
       "entrypoint": "./src/index.cjs",