pi-fabric 0.84.2 → 0.84.4

package/dist/chunks/{chunk-2NI5YMKK.js → chunk-257ES5IL.js}

@@ -2885,13 +2885,253 @@ var actorDeliveryNotice = (delivery, triggerTurn) => {
 };
 
 // src/actors/directory.ts
-import fs12 from "node:fs";
+import fs15 from "node:fs";
+
+// src/actors/manager.ts
+import { randomUUID as randomUUID7 } from "node:crypto";
+import fs14 from "node:fs";
+
+// src/actors/mesh-monitor.ts
+import fs10 from "node:fs";
+import path12 from "node:path";
+var MESH_WATCH_RECONCILE_MS = 2e3;
+var ActorMeshMonitor = class {
+  constructor(mesh, config, callbacks) {
+    this.mesh = mesh;
+    this.config = config;
+    this.callbacks = callbacks;
+    this.#offset = this.#readCursor() ?? mesh.latestOffset();
+  }
+  #timer;
+  #watcher;
+  #offset;
+  #scheduled = false;
+  #polling = false;
+  #closed = false;
+  #started = false;
+  start() {
+    if (this.#started || this.#closed || !this.config.enabled) return;
+    this.#started = true;
+    if (process.platform === "win32") {
+      this.#startTimer(this.config.actorPollMs);
+      this.schedule();
+      return;
+    }
+    try {
+      const watcher = fs10.watch(this.mesh.root, { persistent: false }, (_event, filename) => {
+        if (filename !== null && path12.basename(filename.toString()) !== "events.jsonl") return;
+        this.schedule();
+      });
+      this.#watcher = watcher;
+      watcher.on("error", () => this.#fallback(watcher));
+      this.#startTimer(Math.max(MESH_WATCH_RECONCILE_MS, this.config.actorPollMs));
+    } catch {
+      this.#startTimer(this.config.actorPollMs);
+    }
+    this.schedule();
+  }
+  close() {
+    this.#closed = true;
+    if (this.#timer) clearInterval(this.#timer);
+    this.#timer = void 0;
+    this.#watcher?.close();
+    this.#watcher = void 0;
+  }
+  schedule() {
+    if (this.#scheduled || this.#closed || !this.config.enabled) return;
+    this.#scheduled = true;
+    queueMicrotask(() => {
+      this.#scheduled = false;
+      if (this.#closed) return;
+      void this.#poll().catch(() => void 0);
+    });
+  }
+  #fallback(watcher) {
+    if (this.#closed || this.#watcher !== watcher) return;
+    watcher.close();
+    this.#watcher = void 0;
+    this.#startTimer(this.config.actorPollMs);
+    this.schedule();
+  }
+  #startTimer(delay5) {
+    if (this.#timer) clearInterval(this.#timer);
+    this.#timer = setInterval(() => this.schedule(), delay5);
+    this.#timer.unref();
+  }
+  async #poll() {
+    if (this.#polling || this.#closed || !this.config.enabled) return;
+    if (!this.callbacks.beforePoll()) return;
+    this.#polling = true;
+    try {
+      const tail = this.mesh.tail(this.#offset, this.config.maxReadEvents);
+      this.#offset = tail.nextOffset;
+      for (const event of tail.events) this.callbacks.onEvent(event);
+      this.#writeCursor();
+    } finally {
+      this.#polling = false;
+    }
+  }
+  #readCursor() {
+    if (!this.callbacks.cursorPath) return void 0;
+    try {
+      const value = JSON.parse(fs10.readFileSync(this.callbacks.cursorPath, "utf8"));
+      return value.format === 1 && typeof value.cursor === "number" && value.cursor >= 0 ? value.cursor : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  #writeCursor() {
+    if (!this.callbacks.cursorPath) return;
+    try {
+      writeJsonAtomic(this.callbacks.cursorPath, { format: 1, cursor: this.#offset }, { space: 2 });
+    } catch {
+    }
+  }
+};
 
 // src/actors/manager.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
-import fs11 from "node:fs";
 import os4 from "node:os";
+import path16 from "node:path";
+
+// src/actors/log-store.ts
+import fs11 from "node:fs";
 import path13 from "node:path";
+var ACTOR_MESSAGE_HISTORY_LIMIT = 100;
+var ACTOR_MESSAGE_ENVELOPE_BYTES = 4096;
+var ACTOR_TRUNCATION_SUFFIX = "\n[actor message truncated]";
+var serializedBytes = (value) => Buffer.byteLength(JSON.stringify(value), "utf8");
+var truncateUtf8 = (value, maxBytes, suffix = "") => {
+  if (Buffer.byteLength(value, "utf8") <= maxBytes) return value;
+  const boundedSuffix = Buffer.byteLength(suffix, "utf8") <= maxBytes ? suffix : truncateUtf8(suffix, maxBytes);
+  const available = Math.max(0, maxBytes - Buffer.byteLength(boundedSuffix, "utf8"));
+  let low = 0;
+  let high = value.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(value.slice(0, middle), "utf8") <= available) low = middle;
+    else high = middle - 1;
+  }
+  return `${value.slice(0, low)}${boundedSuffix}`;
+};
+var boundedActorText = (value, maxBytes) => {
+  if (serializedBytes({ text: value }) <= maxBytes) return value;
+  const suffix = serializedBytes({ text: ACTOR_TRUNCATION_SUFFIX }) <= maxBytes ? ACTOR_TRUNCATION_SUFFIX : "";
+  let low = 0;
+  let high = value.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (serializedBytes({ text: `${value.slice(0, middle)}${suffix}` }) <= maxBytes) {
+      low = middle;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return `${value.slice(0, low)}${suffix}`;
+};
+var boundedActorData = (data, maxBytes) => {
+  let serialized;
+  try {
+    const encoded = JSON.stringify(data);
+    serialized = typeof encoded === "string" ? encoded : String(data);
+    if (serializedBytes({ data }) <= maxBytes) return data;
+  } catch {
+    serialized = String(data);
+  }
+  const originalBytes = Buffer.byteLength(serialized, "utf8");
+  let preview = truncateUtf8(serialized, Math.max(0, maxBytes - 256));
+  let bounded = { fabricTruncated: true, originalBytes, preview };
+  while (preview && serializedBytes({ data: bounded }) > maxBytes) {
+    preview = truncateUtf8(preview, Math.floor(Buffer.byteLength(preview, "utf8") / 2));
+    bounded = { fabricTruncated: true, originalBytes, preview };
+  }
+  return serializedBytes({ data: bounded }) <= maxBytes ? bounded : { fabricTruncated: true, originalBytes };
+};
+var ActorLogStore = class {
+  constructor(mesh, config, retention) {
+    this.mesh = mesh;
+    this.config = config;
+    this.retention = retention;
+  }
+  async retainRun(actor, runId, runDirectory) {
+    if (!runDirectory || !fs11.existsSync(runDirectory)) return;
+    const dest = path13.join(path13.dirname(actor.sessionFile), "runs", runId);
+    fs11.mkdirSync(dest, { recursive: true, mode: 448 });
+    for (const file of ["events.jsonl", "status.json", "task.txt"]) {
+      const src = path13.join(runDirectory, file);
+      if (fs11.existsSync(src)) fs11.copyFileSync(src, path13.join(dest, file));
+    }
+    const nested = path13.join(runDirectory, "nested");
+    if (fs11.existsSync(nested)) {
+      try {
+        fs11.cpSync(nested, path13.join(dest, "nested"), { recursive: true });
+      } catch {
+      }
+    }
+    this.pruneRuns(actor);
+  }
+  pruneRuns(actor, now = Date.now()) {
+    pruneActorRunArchives({
+      runsDirectory: path13.join(path13.dirname(actor.sessionFile), "runs"),
+      ...actor.lastRunId ? { latestRunId: actor.lastRunId } : {},
+      retentionMs: this.retention.actorRunArchiveMs,
+      now
+    });
+  }
+  retainedRunIds(actor) {
+    const runsDir = path13.join(path13.dirname(actor.sessionFile), "runs");
+    try {
+      return fs11.readdirSync(runsDir).sort();
+    } catch {
+      return [];
+    }
+  }
+  recordMessage(messages, message) {
+    let bounded = structuredClone(message);
+    const maxPayloadBytes = Math.max(1, this.mesh.maxEventBytes - ACTOR_MESSAGE_ENVELOPE_BYTES);
+    const fixed = structuredClone(bounded);
+    delete fixed.text;
+    delete fixed.data;
+    const contentBytes = Math.max(1, maxPayloadBytes - serializedBytes(fixed) - 128);
+    const hasText = Boolean(bounded.text);
+    const hasData = bounded.data !== void 0;
+    const textBytes = hasText && hasData ? Math.floor(contentBytes / 2) : contentBytes;
+    const dataBytes = hasText && hasData ? contentBytes - textBytes : contentBytes;
+    if (bounded.text) {
+      const contextBounded = bounded.text.length > this.config.eventContextChars ? `${bounded.text.slice(0, this.config.eventContextChars)}${ACTOR_TRUNCATION_SUFFIX}` : bounded.text;
+      bounded.text = boundedActorText(contextBounded, textBytes);
+    }
+    if (bounded.data !== void 0) {
+      bounded.data = boundedActorData(bounded.data, dataBytes);
+    }
+    if (serializedBytes(bounded) > maxPayloadBytes) {
+      delete bounded.data;
+      if (bounded.text) {
+        bounded.text = boundedActorText(bounded.text, contentBytes);
+      }
+    }
+    if (serializedBytes(bounded) > maxPayloadBytes) {
+      bounded = {
+        id: bounded.id,
+        actorId: bounded.actorId,
+        actorName: bounded.actorName,
+        direction: bounded.direction,
+        source: boundedActorText(bounded.source, 1024),
+        createdAt: bounded.createdAt,
+        ...bounded.action ? { action: bounded.action } : {},
+        ...bounded.runId ? { runId: bounded.runId } : {},
+        error: "Actor message content exceeded the mesh event limit"
+      };
+    }
+    for (const key of Object.keys(message)) {
+      delete message[key];
+    }
+    Object.assign(message, bounded);
+    messages.push(bounded);
+    if (messages.length > ACTOR_MESSAGE_HISTORY_LIMIT) {
+      messages.splice(0, messages.length - ACTOR_MESSAGE_HISTORY_LIMIT);
+    }
+  }
+};
 
 // src/actors/predicate.ts
 var PREDICATE_VERSION = 1;
@@ -2962,8 +3202,8 @@ var evaluateActorValidWhile = async (source, facts) => {
 
 // src/actors/binding-store.ts
 import { createHash, randomUUID as randomUUID5 } from "node:crypto";
-import fs10 from "node:fs";
-import path12 from "node:path";
+import fs12 from "node:fs";
+import path14 from "node:path";
 var BINDING_LOCK_TIMEOUT_MS = 5e3;
 var BINDING_STALE_LOCK_MS = 3e4;
 var bindingFileName = (sessionId) => `${createHash("sha256").update(sessionId).digest("hex")}.json`;
@@ -2973,7 +3213,7 @@ var delay3 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var ActorBindingStore = class {
   constructor(sessionId, root) {
     this.sessionId = sessionId;
-    this.filePath = root ? path12.join(root, "bindings", bindingFileName(sessionId)) : void 0;
+    this.filePath = root ? path14.join(root, "bindings", bindingFileName(sessionId)) : void 0;
     this.#sync(true);
   }
   #bindings = /* @__PURE__ */ new Map();
@@ -3039,7 +3279,7 @@ var ActorBindingStore = class {
     if (!this.filePath) return bindings;
     let parsed;
     try {
-      parsed = JSON.parse(fs10.readFileSync(this.filePath, "utf8"));
+      parsed = JSON.parse(fs12.readFileSync(this.filePath, "utf8"));
     } catch {
       return bindings;
     }
@@ -3080,7 +3320,7 @@ var ActorBindingStore = class {
   #currentFingerprint() {
     if (!this.filePath) return void 0;
     try {
-      const stat = fs10.statSync(this.filePath);
+      const stat = fs12.statSync(this.filePath);
       return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}`;
     } catch {
       return void 0;
@@ -3089,7 +3329,7 @@ var ActorBindingStore = class {
   async #withLock(operation) {
     if (!this.filePath) return operation();
     const lockPath = `${this.filePath}.lock`;
-    const ownerPath2 = path12.join(lockPath, "owner");
+    const ownerPath2 = path14.join(lockPath, "owner");
     const deadline = Date.now() + BINDING_LOCK_TIMEOUT_MS;
     const token = randomUUID5();
     const processAlive3 = (pid) => {
@@ -3101,11 +3341,11 @@ var ActorBindingStore = class {
         return false;
       }
     };
-    fs10.mkdirSync(path12.dirname(this.filePath), { recursive: true, mode: 448 });
+    fs12.mkdirSync(path14.dirname(this.filePath), { recursive: true, mode: 448 });
     while (true) {
       try {
-        fs10.mkdirSync(lockPath, { mode: 448 });
-        fs10.writeFileSync(ownerPath2, `${token}
+        fs12.mkdirSync(lockPath, { mode: 448 });
+        fs12.writeFileSync(ownerPath2, `${token}
 ${process.pid}
 ${Date.now()}
 `, {
@@ -3116,13 +3356,13 @@ ${Date.now()}
       } catch (error) {
         if (errorCode2(error) !== "EEXIST") throw error;
         try {
-          const firstOwner = fs10.readFileSync(ownerPath2, "utf8");
+          const firstOwner = fs12.readFileSync(ownerPath2, "utf8");
           const [, pidText, createdText] = firstOwner.trim().split("\n");
           const stale = Date.now() - Number(createdText) > BINDING_STALE_LOCK_MS;
           if (stale && !processAlive3(Number(pidText))) {
-            const secondOwner = fs10.readFileSync(ownerPath2, "utf8");
+            const secondOwner = fs12.readFileSync(ownerPath2, "utf8");
             if (secondOwner === firstOwner) {
-              fs10.rmSync(lockPath, { recursive: true, force: true });
+              fs12.rmSync(lockPath, { recursive: true, force: true });
               continue;
             }
           }
@@ -3138,10 +3378,10 @@ ${Date.now()}
       return operation();
     } finally {
       try {
-        const owner = fs10.readFileSync(ownerPath2, "utf8");
+        const owner = fs12.readFileSync(ownerPath2, "utf8");
         if (owner.startsWith(`${token}
 `)) {
-          fs10.rmSync(lockPath, { recursive: true, force: true });
+          fs12.rmSync(lockPath, { recursive: true, force: true });
         }
       } catch {
       }
@@ -3149,6 +3389,110 @@ ${Date.now()}
   }
 };
 
+// src/actors/registry-store.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
+import fs13 from "node:fs";
+import path15 from "node:path";
+var ACTOR_REGISTRY_LOCK_TIMEOUT_MS = 5e3;
+var ACTOR_REGISTRY_STALE_LOCK_MS = 3e4;
+var delay4 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var errorCode3 = (error) => error instanceof Error && "code" in error ? String(error.code) : void 0;
+var ActorRegistryStore = class {
+  #registryPath;
+  #actorRoot;
+  constructor(actorRoot) {
+    this.#actorRoot = actorRoot;
+    this.#registryPath = path15.join(actorRoot, "actors.json");
+  }
+  records() {
+    try {
+      const parsed = JSON.parse(fs13.readFileSync(this.#registryPath, "utf8"));
+      if (!Array.isArray(parsed.actors)) return [];
+      return parsed.actors.flatMap(
+        (record) => typeof record === "object" && record !== null && !Array.isArray(record) && typeof record.id === "string" ? [record] : []
+      );
+    } catch {
+      return [];
+    }
+  }
+  /** The callback must be synchronous: release precedes promise assimilation. */
+  async withLock(operation) {
+    const lockPath = `${this.#registryPath}.lock`;
+    const ownerPath2 = path15.join(lockPath, "owner");
+    const deadline = Date.now() + ACTOR_REGISTRY_LOCK_TIMEOUT_MS;
+    const token = randomUUID6();
+    const processAlive3 = (pid) => {
+      if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    fs13.mkdirSync(this.#actorRoot, { recursive: true, mode: 448 });
+    while (true) {
+      try {
+        fs13.mkdirSync(lockPath, { mode: 448 });
+        fs13.writeFileSync(ownerPath2, `${token}
+${process.pid}
+${Date.now()}
+`, {
+          encoding: "utf8",
+          mode: 384
+        });
+        break;
+      } catch (error) {
+        if (errorCode3(error) !== "EEXIST") throw error;
+        try {
+          const firstOwner = fs13.readFileSync(ownerPath2, "utf8");
+          const [, pidText, createdText] = firstOwner.trim().split("\n");
+          const stale = Date.now() - Number(createdText) > ACTOR_REGISTRY_STALE_LOCK_MS;
+          if (stale && !processAlive3(Number(pidText))) {
+            const secondOwner = fs13.readFileSync(ownerPath2, "utf8");
+            if (secondOwner === firstOwner) {
+              fs13.rmSync(lockPath, { recursive: true, force: true });
+              continue;
+            }
+          }
+        } catch {
+        }
+        if (Date.now() >= deadline) {
+          throw new Error("Timed out waiting for the Fabric actor registry lock");
+        }
+        await delay4(10);
+      }
+    }
+    try {
+      return operation();
+    } finally {
+      try {
+        const owner = fs13.readFileSync(ownerPath2, "utf8");
+        if (owner.startsWith(`${token}
+`)) {
+          fs13.rmSync(lockPath, { recursive: true, force: true });
+        }
+      } catch {
+      }
+    }
+  }
+  fingerprint() {
+    try {
+      const stat = fs13.statSync(this.#registryPath);
+      return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}`;
+    } catch {
+      return void 0;
+    }
+  }
+  read() {
+    return JSON.parse(fs13.readFileSync(this.#registryPath, "utf8"));
+  }
+  /** Call within withLock for read-modify-write operations. */
+  write(actors) {
+    writeJsonAtomic(this.#registryPath, { format: 1, actors }, { space: 2 });
+  }
+};
+
 // src/actors/manager.ts
 var ACTOR_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9 _.-]{0,59}$/;
 var TOPIC_PATTERN2 = /^[a-zA-Z0-9][a-zA-Z0-9._:/-]{0,127}$/;
@@ -3160,62 +3504,9 @@ var MAIN_REVISION_EVENTS = /* @__PURE__ */ new Set([
   "tool_error",
   "session_compact"
 ]);
-var MESSAGE_HISTORY_LIMIT = 100;
-var MESH_WATCH_RECONCILE_MS = 2e3;
-var ACTOR_REGISTRY_LOCK_TIMEOUT_MS = 5e3;
 var ORPHAN_ADOPTION_RETRY_MS = 3e4;
-var ACTOR_REGISTRY_STALE_LOCK_MS = 3e4;
 var RETENTION_SWEEP_INTERVAL_MS2 = 15 * 60 * 1e3;
 var RESIDENT_HOST_EVENT_TOPIC = "fabric.actor.host-event";
-var ACTOR_MESSAGE_ENVELOPE_BYTES = 4096;
-var ACTOR_TRUNCATION_SUFFIX = "\n[actor message truncated]";
-var serializedBytes = (value) => Buffer.byteLength(JSON.stringify(value), "utf8");
-var truncateUtf8 = (value, maxBytes, suffix = "") => {
-  if (Buffer.byteLength(value, "utf8") <= maxBytes) return value;
-  const boundedSuffix = Buffer.byteLength(suffix, "utf8") <= maxBytes ? suffix : truncateUtf8(suffix, maxBytes);
-  const available = Math.max(0, maxBytes - Buffer.byteLength(boundedSuffix, "utf8"));
-  let low = 0;
-  let high = value.length;
-  while (low < high) {
-    const middle = Math.ceil((low + high) / 2);
-    if (Buffer.byteLength(value.slice(0, middle), "utf8") <= available) low = middle;
-    else high = middle - 1;
-  }
-  return `${value.slice(0, low)}${boundedSuffix}`;
-};
-var boundedActorText = (value, maxBytes) => {
-  if (serializedBytes({ text: value }) <= maxBytes) return value;
-  const suffix = serializedBytes({ text: ACTOR_TRUNCATION_SUFFIX }) <= maxBytes ? ACTOR_TRUNCATION_SUFFIX : "";
-  let low = 0;
-  let high = value.length;
-  while (low < high) {
-    const middle = Math.ceil((low + high) / 2);
-    if (serializedBytes({ text: `${value.slice(0, middle)}${suffix}` }) <= maxBytes) {
-      low = middle;
-    } else {
-      high = middle - 1;
-    }
-  }
-  return `${value.slice(0, low)}${suffix}`;
-};
-var boundedActorData = (data, maxBytes) => {
-  let serialized;
-  try {
-    const encoded = JSON.stringify(data);
-    serialized = typeof encoded === "string" ? encoded : String(data);
-    if (serializedBytes({ data }) <= maxBytes) return data;
-  } catch {
-    serialized = String(data);
-  }
-  const originalBytes = Buffer.byteLength(serialized, "utf8");
-  let preview = truncateUtf8(serialized, Math.max(0, maxBytes - 256));
-  let bounded = { fabricTruncated: true, originalBytes, preview };
-  while (preview && serializedBytes({ data: bounded }) > maxBytes) {
-    preview = truncateUtf8(preview, Math.floor(Buffer.byteLength(preview, "utf8") / 2));
-    bounded = { fabricTruncated: true, originalBytes, preview };
-  }
-  return serializedBytes({ data: bounded }) <= maxBytes ? bounded : { fabricTruncated: true, originalBytes };
-};
 var normalizeCapabilityRequirements = (requirements = []) => {
   const normalized = /* @__PURE__ */ new Map();
   for (const requirement of requirements) {
@@ -3230,14 +3521,9 @@ var normalizeCapabilityRequirements = (requirements = []) => {
   if (normalized.size > 128) throw new Error("Actors may require at most 128 Fabric capabilities");
   return [...normalized].sort(([left], [right]) => left.localeCompare(right)).map(([ref, optional]) => ({ ref, ...optional ? { optional: true } : {} }));
 };
-var delay4 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-var errorCode3 = (error) => error instanceof Error && "code" in error ? String(error.code) : void 0;
-var atomicWrite2 = (filePath, value) => {
-  writeJsonAtomic(filePath, value, { space: 2 });
-};
 var readRunRecord = (filePath) => {
   try {
-    const parsed = JSON.parse(fs11.readFileSync(filePath, "utf8"));
+    const parsed = JSON.parse(fs14.readFileSync(filePath, "utf8"));
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
     return parsed;
   } catch {
@@ -3287,7 +3573,7 @@ var ActorManager = class {
     this.meshConfig = meshConfig;
     this.agents = agents;
     this.onDeliver = onDeliver;
-    this.#actorRoot = options.actorRoot ?? fs11.mkdtempSync(path13.join(os4.tmpdir(), "pi-fabric-actors-"));
+    this.#actorRoot = options.actorRoot ?? fs14.mkdtempSync(path16.join(os4.tmpdir(), "pi-fabric-actors-"));
     this.#actorScope = options.actorScope ?? meshConfig.actorScope;
     this.#persistent = options.persistent ?? false;
     this.#mainAgent = options.mainAgent;
@@ -3297,30 +3583,44 @@ var ActorManager = class {
     this.#adoptionGraceMs = options.adoptionGraceMs ?? ORPHAN_ADOPTION_RETRY_MS;
     this.#claimResidency = options.claimResidency;
     this.#rootId = options.rootId ?? identity.id;
-    this.#meshCursorPath = options.meshCursorPath;
     this.#relayParticipantSteering = options.relayParticipantSteering ?? true;
-    this.#registryPath = path13.join(this.#actorRoot, "actors.json");
+    this.#logs = new ActorLogStore(
+      mesh,
+      meshConfig,
+      options.retention ?? DEFAULT_FABRIC_CONFIG.retention
+    );
+    this.#registry = new ActorRegistryStore(this.#actorRoot);
     this.#bindings = new ActorBindingStore(
       sessionId,
       this.#persistent && meshConfig.enabled ? this.#actorRoot : void 0
     );
     if (this.#persistent && meshConfig.enabled) this.#loadActors();
-    this.#registryFingerprint = this.#currentRegistryFingerprint();
+    this.#registryFingerprint = this.#registry.fingerprint();
     for (const actor of this.#actors.values()) {
       this.#ownership.set(actor.id, this.#ownershipDecision(actor.id));
     }
-    this.#retention = options.retention ?? DEFAULT_FABRIC_CONFIG.retention;
     this.#acquireCapabilityView = options.acquireCapabilityView;
     this.#sweepRetainedRuns();
     this.#retentionTimer = setInterval(() => this.#sweepRetainedRuns(), RETENTION_SWEEP_INTERVAL_MS2);
     this.#retentionTimer.unref();
-    this.#meshOffset = this.#readMeshCursor() ?? mesh.latestOffset();
-    this.#startMeshMonitor();
+    this.#meshMonitor = new ActorMeshMonitor(mesh, meshConfig, {
+      cursorPath: options.meshCursorPath,
+      beforePoll: () => {
+        this.#syncActorsFromRegistry();
+        this.#refreshOwnership();
+        return !this.#halted;
+      },
+      onEvent: (event) => {
+        if (event.topic === "fabric.steer") this.#relaySteer(event);
+        else if (!event.topic.startsWith("fabric.control.")) this.#dispatchMeshEvent(event);
+      }
+    });
+    this.#meshMonitor.start();
   }
   #actors = /* @__PURE__ */ new Map();
   #actorRoot;
   #actorScope;
-  #registryPath;
+  #registry;
   #persistent;
   #bindings;
   #mainAgent;
@@ -3329,9 +3629,9 @@ var ActorManager = class {
   #lineageAlive;
   #claimResidency;
   #rootId;
-  #meshCursorPath;
+  #meshMonitor;
   #relayParticipantSteering;
-  #retention;
+  #logs;
   #acquireCapabilityView;
   #locallyCreated = /* @__PURE__ */ new Set();
   #ceded = /* @__PURE__ */ new Set();
@@ -3344,12 +3644,7 @@ var ActorManager = class {
   #adoptionPending = /* @__PURE__ */ new Set();
   #adoptionGraceMs;
   #listeners = /* @__PURE__ */ new Set();
-  #pollTimer;
   #retentionTimer;
-  #meshWatcher;
-  #meshOffset;
-  #meshPollScheduled = false;
-  #polling = false;
   #closing = false;
   // Stop-the-world gate armed by haltAll() (ESC): while true, host-event and
   // mesh dispatch are frozen so interrupted actors are not re-armed by the
@@ -3423,9 +3718,9 @@ var ActorManager = class {
     if (requirements.length > 0 && !this.#acquireCapabilityView) {
       throw new Error("This Fabric host cannot commit actor capability requirements");
     }
-    const id = randomUUID6().replaceAll("-", "");
-    const actorDirectory = path13.join(this.#actorRoot, id);
-    fs11.mkdirSync(actorDirectory, { recursive: true, mode: 448 });
+    const id = randomUUID7().replaceAll("-", "");
+    const actorDirectory = path16.join(this.#actorRoot, id);
+    fs14.mkdirSync(actorDirectory, { recursive: true, mode: 448 });
     const actor = {
       id,
       name,
@@ -3449,7 +3744,7 @@ var ActorManager = class {
       requirements,
       ...request.validWhile ? { validWhile: structuredClone(request.validWhile) } : {},
       latestActivationSequence: 0,
-      sessionFile: path13.join(actorDirectory, "session.jsonl"),
+      sessionFile: path16.join(actorDirectory, "session.jsonl"),
       queue: [],
       draining: false,
       messages: [],
@@ -3733,7 +4028,7 @@ var ActorManager = class {
   messages(id, limit = 50) {
     this.#syncActorsFromRegistry();
     const actor = this.#requireActor(id);
-    const bounded = Math.max(1, Math.min(Math.floor(limit), MESSAGE_HISTORY_LIMIT));
+    const bounded = Math.max(1, Math.min(Math.floor(limit), ACTOR_MESSAGE_HISTORY_LIMIT));
     return actor.messages.slice(-bounded).map((message) => structuredClone(message));
   }
   /**
@@ -3782,17 +4077,17 @@ var ActorManager = class {
     const type = opts.type ?? "session";
     const lines = Math.max(1, Math.min(opts.lines ?? 200, 5e3));
     const sessionFile = actor.sessionFile;
-    const logDir = path13.join(path13.dirname(sessionFile), "runs");
+    const logDir = path16.join(path16.dirname(sessionFile), "runs");
     const sessionPage = type === "run" ? { lines: [], hasMore: false } : readJsonlPage(sessionFile, lines, opts.before);
     const session = sessionPage.lines;
     let run;
     if (type !== "session") {
       const targetRunId = opts.runId ?? actor.lastRunId;
       if (targetRunId) {
-        const runPath = path13.join(logDir, targetRunId);
-        if (fs11.existsSync(runPath)) {
-          const statusRecord = readRunRecord(path13.join(runPath, "status.json"));
-          const eventsFile = path13.join(runPath, "events.jsonl");
+        const runPath = path16.join(logDir, targetRunId);
+        if (fs14.existsSync(runPath)) {
+          const statusRecord = readRunRecord(path16.join(runPath, "status.json"));
+          const eventsFile = path16.join(runPath, "events.jsonl");
           const page = readJsonlPage(eventsFile, lines, opts.before);
           run = {
             runId: targetRunId,
@@ -3814,7 +4109,7 @@ var ActorManager = class {
       sessionHasMore: sessionPage.hasMore,
       ...sessionPage.before !== void 0 ? { sessionBefore: sessionPage.before } : {},
       ...run ? { run } : {},
-      retainedRuns: this.#retainedRunIds(actor)
+      retainedRuns: this.#logs.retainedRunIds(actor)
     };
   }
   noteMainActivity(idle = false) {
@@ -3905,22 +4200,6 @@ var ActorManager = class {
       ownershipChecked: true
     });
   }
-  #readMeshCursor() {
-    if (!this.#meshCursorPath) return void 0;
-    try {
-      const value = JSON.parse(fs11.readFileSync(this.#meshCursorPath, "utf8"));
-      return value.format === 1 && typeof value.cursor === "number" && value.cursor >= 0 ? value.cursor : void 0;
-    } catch {
-      return void 0;
-    }
-  }
-  #writeMeshCursor() {
-    if (!this.#meshCursorPath) return;
-    try {
-      atomicWrite2(this.#meshCursorPath, { format: 1, cursor: this.#meshOffset });
-    } catch {
-    }
-  }
   #beginHostEvent(event, idle) {
     if (this.#closing || !this.meshConfig.enabled) return false;
     if (!MAIN_REVISION_EVENTS.has(event) && ![...this.#actors.values()].some((actor) => this.#observesHostEvent(actor, event))) return false;
@@ -3928,7 +4207,7 @@ var ActorManager = class {
     this.#refreshOwnership();
     if (event === "input" && this.#halted) {
       this.#halted = false;
-      this.#scheduleMeshPoll();
+      this.#meshMonitor.schedule();
     }
     if (this.#halted) return false;
     if (MAIN_REVISION_EVENTS.has(event)) this.#mainRevision++;
@@ -4009,7 +4288,7 @@ var ActorManager = class {
     await this.#bindings.delete(actor.id);
     this.#actors.delete(actor.id);
     this.#emitChange();
-    fs11.rmSync(path13.dirname(actor.sessionFile), { recursive: true, force: true });
+    fs14.rmSync(path16.dirname(actor.sessionFile), { recursive: true, force: true });
     await this.#saveActors(/* @__PURE__ */ new Set([actor.id]));
     await this.mesh.delete({ key: this.#presenceKey(actor.id) }).catch(() => ({ deleted: false }));
     if (retainedRunId) await this.agents.cleanup(retainedRunId).catch(() => ({ cleaned: false }));
@@ -4018,12 +4297,9 @@ var ActorManager = class {
   async close() {
     if (this.#closing) return;
     this.#closing = true;
-    if (this.#pollTimer) clearInterval(this.#pollTimer);
-    this.#pollTimer = void 0;
+    this.#meshMonitor.close();
     if (this.#retentionTimer) clearInterval(this.#retentionTimer);
     this.#retentionTimer = void 0;
-    this.#meshWatcher?.close();
-    this.#meshWatcher = void 0;
     this.#listeners.clear();
     if (this.#persistent) {
       this.#refreshOwnership();
@@ -4052,7 +4328,7 @@ var ActorManager = class {
     await Promise.allSettled(
       [...this.#actors.values()].map((actor) => actor.drain ?? Promise.resolve())
     );
-    fs11.rmSync(this.#actorRoot, { recursive: true, force: true });
+    fs14.rmSync(this.#actorRoot, { recursive: true, force: true });
   }
   #enqueue(actor, source, payload, options = {}) {
     const canManage = options.ownershipChecked ? this.#canManageCached(actor.id) : this.#canManage(actor.id);
@@ -4092,7 +4368,7 @@ var ActorManager = class {
         `Fabric actor queue limit reached for ${actor.name} (${this.meshConfig.actorQueueLimit})`
       );
     }
-    const itemId = randomUUID6();
+    const itemId = randomUUID7();
     const item = {
       id: itemId,
       source,
@@ -4205,7 +4481,7 @@ var ActorManager = class {
             if (actor.responseMode === "directive") {
               const reason = result.error || `Actor run ${result.status}`;
               const silent = {
-                id: randomUUID6(),
+                id: randomUUID7(),
                 actorId: actor.id,
                 actorName: actor.name,
                 direction: "out",
@@ -4270,7 +4546,7 @@ var ActorManager = class {
           }
           actor.lastError = message;
           const failed = {
-            id: randomUUID6(),
+            id: randomUUID7(),
             actorId: actor.id,
             actorName: actor.name,
             direction: "out",
@@ -4352,7 +4628,7 @@ var ActorManager = class {
     if (actor.responseMode === "directive") {
       const directive = asDirective(result);
       return {
-        id: randomUUID6(),
+        id: randomUUID7(),
         actorId: actor.id,
         actorName: actor.name,
         direction: "out",
@@ -4366,7 +4642,7 @@ var ActorManager = class {
       };
     }
     return {
-      id: randomUUID6(),
+      id: randomUUID7(),
       actorId: actor.id,
       actorName: actor.name,
       direction: "out",
@@ -4421,7 +4697,7 @@ var ActorManager = class {
   }
   #recordStale(actor, item, reason = "validWhile returned false", runId, usage) {
     const message = {
-      id: randomUUID6(),
+      id: randomUUID7(),
       actorId: actor.id,
       actorName: actor.name,
       direction: "out",
@@ -4436,65 +4712,6 @@ var ActorManager = class {
     this.#recordMessage(actor, message);
     item.reject?.(new Error(`Fabric actor activation invalidated: ${reason}`));
   }
-  #startMeshMonitor() {
-    if (!this.meshConfig.enabled || this.#closing) return;
-    if (process.platform === "win32") {
-      this.#startPollTimer(this.meshConfig.actorPollMs);
-      this.#scheduleMeshPoll();
-      return;
-    }
-    try {
-      const watcher = fs11.watch(this.mesh.root, { persistent: false }, (_event, filename) => {
-        if (filename !== null && path13.basename(filename.toString()) !== "events.jsonl") return;
-        this.#scheduleMeshPoll();
-      });
-      this.#meshWatcher = watcher;
-      watcher.on("error", () => this.#fallBackToMeshPolling(watcher));
-      this.#startPollTimer(Math.max(MESH_WATCH_RECONCILE_MS, this.meshConfig.actorPollMs));
-    } catch {
-      this.#startPollTimer(this.meshConfig.actorPollMs);
-    }
-    this.#scheduleMeshPoll();
-  }
-  #fallBackToMeshPolling(watcher) {
-    if (this.#closing || this.#meshWatcher !== watcher) return;
-    watcher.close();
-    this.#meshWatcher = void 0;
-    this.#startPollTimer(this.meshConfig.actorPollMs);
-    this.#scheduleMeshPoll();
-  }
-  #startPollTimer(delay5) {
-    if (this.#pollTimer) clearInterval(this.#pollTimer);
-    this.#pollTimer = setInterval(() => this.#scheduleMeshPoll(), delay5);
-    this.#pollTimer.unref();
-  }
-  #scheduleMeshPoll() {
-    if (this.#meshPollScheduled || this.#closing || !this.meshConfig.enabled) return;
-    this.#meshPollScheduled = true;
-    queueMicrotask(() => {
-      this.#meshPollScheduled = false;
-      if (this.#closing) return;
-      void this.#pollMesh().catch(() => void 0);
-    });
-  }
-  async #pollMesh() {
-    if (this.#polling || this.#closing || !this.meshConfig.enabled) return;
-    this.#syncActorsFromRegistry();
-    this.#refreshOwnership();
-    if (this.#halted) return;
-    this.#polling = true;
-    try {
-      const tail = this.mesh.tail(this.#meshOffset, this.meshConfig.maxReadEvents);
-      this.#meshOffset = tail.nextOffset;
-      for (const event of tail.events) {
-        if (event.topic === "fabric.steer") this.#relaySteer(event);
-        else if (!event.topic.startsWith("fabric.control.")) this.#dispatchMeshEvent(event);
-      }
-      this.#writeMeshCursor();
-    } finally {
-      this.#polling = false;
-    }
-  }
   /**
    * Receive legacy fabric.steer events from older Fabric writers. This path is
    * intentionally best-effort; current writers use acknowledged owner-addressed
@@ -4555,91 +4772,17 @@ var ActorManager = class {
     }
   }
   async #retainRunLog(actor, runId) {
-    const runDirectory = this.agents.runDirectory(runId);
-    if (!runDirectory || !fs11.existsSync(runDirectory)) return;
-    const dest = path13.join(path13.dirname(actor.sessionFile), "runs", runId);
-    fs11.mkdirSync(dest, { recursive: true, mode: 448 });
-    for (const file of ["events.jsonl", "status.json", "task.txt"]) {
-      const src = path13.join(runDirectory, file);
-      if (fs11.existsSync(src)) fs11.copyFileSync(src, path13.join(dest, file));
-    }
-    const nested = path13.join(runDirectory, "nested");
-    if (fs11.existsSync(nested)) {
-      try {
-        fs11.cpSync(nested, path13.join(dest, "nested"), { recursive: true });
-      } catch {
-      }
-    }
-    this.#pruneRetainedRuns(actor);
-  }
-  #pruneRetainedRuns(actor, now = Date.now()) {
-    pruneActorRunArchives({
-      runsDirectory: path13.join(path13.dirname(actor.sessionFile), "runs"),
-      ...actor.lastRunId ? { latestRunId: actor.lastRunId } : {},
-      retentionMs: this.#retention.actorRunArchiveMs,
-      now
-    });
+    await this.#logs.retainRun(actor, runId, this.agents.runDirectory(runId));
   }
   #sweepRetainedRuns(now = Date.now()) {
     if (this.#closing) return;
     this.#refreshOwnership();
     for (const actor of this.#actors.values()) {
-      if (this.#canManage(actor.id)) this.#pruneRetainedRuns(actor, now);
-    }
-  }
-  #retainedRunIds(actor) {
-    const runsDir = path13.join(path13.dirname(actor.sessionFile), "runs");
-    try {
-      return fs11.readdirSync(runsDir).sort();
-    } catch {
-      return [];
+      if (this.#canManage(actor.id)) this.#logs.pruneRuns(actor, now);
     }
   }
   #recordMessage(actor, message) {
-    let bounded = structuredClone(message);
-    const maxPayloadBytes = Math.max(1, this.mesh.maxEventBytes - ACTOR_MESSAGE_ENVELOPE_BYTES);
-    const fixed = structuredClone(bounded);
-    delete fixed.text;
-    delete fixed.data;
-    const contentBytes = Math.max(1, maxPayloadBytes - serializedBytes(fixed) - 128);
-    const hasText = Boolean(bounded.text);
-    const hasData = bounded.data !== void 0;
-    const textBytes = hasText && hasData ? Math.floor(contentBytes / 2) : contentBytes;
-    const dataBytes = hasText && hasData ? contentBytes - textBytes : contentBytes;
-    if (bounded.text) {
-      const contextBounded = bounded.text.length > this.meshConfig.eventContextChars ? `${bounded.text.slice(0, this.meshConfig.eventContextChars)}${ACTOR_TRUNCATION_SUFFIX}` : bounded.text;
-      bounded.text = boundedActorText(contextBounded, textBytes);
-    }
-    if (bounded.data !== void 0) {
-      bounded.data = boundedActorData(bounded.data, dataBytes);
-    }
-    if (serializedBytes(bounded) > maxPayloadBytes) {
-      delete bounded.data;
-      if (bounded.text) {
-        bounded.text = boundedActorText(bounded.text, contentBytes);
-      }
-    }
-    if (serializedBytes(bounded) > maxPayloadBytes) {
-      bounded = {
-        id: bounded.id,
-        actorId: bounded.actorId,
-        actorName: bounded.actorName,
-        direction: bounded.direction,
-        source: boundedActorText(bounded.source, 1024),
-        createdAt: bounded.createdAt,
-        ...bounded.action ? { action: bounded.action } : {},
-        ...bounded.runId ? { runId: bounded.runId } : {},
-        error: "Actor message content exceeded the mesh event limit"
-      };
-    }
-    for (const key of Object.keys(message)) {
-      delete message[key];
-    }
-    Object.assign(message, bounded);
-    actor.messages.push(bounded);
-    if (actor.messages.length > MESSAGE_HISTORY_LIMIT) {
-      actor.messages.splice(0, actor.messages.length - MESSAGE_HISTORY_LIMIT);
-    }
+    this.#logs.recordMessage(actor.messages, message);
   }
   async #publishPresence(actor) {
     if (!this.#canManage(actor.id)) return;
@@ -4704,88 +4847,17 @@ var ActorManager = class {
       ...actor.lastRunId ? { lastRunId: actor.lastRunId } : {}
     };
   }
-  #registryRecords() {
-    try {
-      const parsed = JSON.parse(fs11.readFileSync(this.#registryPath, "utf8"));
-      if (!Array.isArray(parsed.actors)) return [];
-      return parsed.actors.flatMap(
-        (record) => typeof record === "object" && record !== null && !Array.isArray(record) && typeof record.id === "string" ? [record] : []
-      );
-    } catch {
-      return [];
-    }
-  }
-  async #withRegistryLock(operation) {
-    const lockPath = `${this.#registryPath}.lock`;
-    const ownerPath2 = path13.join(lockPath, "owner");
-    const deadline = Date.now() + ACTOR_REGISTRY_LOCK_TIMEOUT_MS;
-    const token = randomUUID6();
-    const processAlive3 = (pid) => {
-      if (!Number.isSafeInteger(pid) || pid <= 0) return false;
-      try {
-        process.kill(pid, 0);
-        return true;
-      } catch {
-        return false;
-      }
-    };
-    fs11.mkdirSync(this.#actorRoot, { recursive: true, mode: 448 });
-    while (true) {
-      try {
-        fs11.mkdirSync(lockPath, { mode: 448 });
-        fs11.writeFileSync(ownerPath2, `${token}
-${process.pid}
-${Date.now()}
-`, {
-          encoding: "utf8",
-          mode: 384
-        });
-        break;
-      } catch (error) {
-        if (errorCode3(error) !== "EEXIST") throw error;
-        try {
-          const firstOwner = fs11.readFileSync(ownerPath2, "utf8");
-          const [, pidText, createdText] = firstOwner.trim().split("\n");
-          const stale = Date.now() - Number(createdText) > ACTOR_REGISTRY_STALE_LOCK_MS;
-          if (stale && !processAlive3(Number(pidText))) {
-            const secondOwner = fs11.readFileSync(ownerPath2, "utf8");
-            if (secondOwner === firstOwner) {
-              fs11.rmSync(lockPath, { recursive: true, force: true });
-              continue;
-            }
-          }
-        } catch {
-        }
-        if (Date.now() >= deadline) {
-          throw new Error("Timed out waiting for the Fabric actor registry lock");
-        }
-        await delay4(10);
-      }
-    }
-    try {
-      return operation();
-    } finally {
-      try {
-        const owner = fs11.readFileSync(ownerPath2, "utf8");
-        if (owner.startsWith(`${token}
-`)) {
-          fs11.rmSync(lockPath, { recursive: true, force: true });
-        }
-      } catch {
-      }
-    }
-  }
   async #saveActors(removedIds = /* @__PURE__ */ new Set()) {
     if (!this.#persistent || !this.meshConfig.enabled) return;
-    await this.#withRegistryLock(() => {
+    await this.#registry.withLock(() => {
       const owned = [...this.#actors.values()].filter(
         (actor) => this.#ownershipDecision(actor.id)
       );
       const replaced = /* @__PURE__ */ new Set([...removedIds, ...owned.map((actor) => actor.id)]);
-      const preserved = this.#registryRecords().filter((record) => !replaced.has(record.id));
+      const preserved = this.#registry.records().filter((record) => !replaced.has(record.id));
       const actors = [...preserved, ...owned.map((actor) => this.#serializedActor(actor))];
-      atomicWrite2(this.#registryPath, { format: 1, actors });
-      this.#registryFingerprint = this.#currentRegistryFingerprint();
+      this.#registry.write(actors);
+      this.#registryFingerprint = this.#registry.fingerprint();
       for (const id of removedIds) this.#persistedRoots.delete(id);
       for (const actor of owned) this.#persistedRoots.set(actor.id, actor.rootId);
       for (const record of preserved) {
@@ -4795,17 +4867,9 @@ ${Date.now()}
     this.#registryFingerprint = void 0;
     this.#syncActorsFromRegistry();
   }
-  #currentRegistryFingerprint() {
-    try {
-      const stat = fs11.statSync(this.#registryPath);
-      return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}`;
-    } catch {
-      return void 0;
-    }
-  }
   #syncActorsFromRegistry() {
     if (!this.#persistent || this.#closing || this.#reloadingOwnership) return;
-    const fingerprint = this.#currentRegistryFingerprint();
+    const fingerprint = this.#registry.fingerprint();
     if (!fingerprint || fingerprint === this.#registryFingerprint) return;
     this.#registryFingerprint = fingerprint;
     const ownsAny = [...this.#actors.keys()].some((id) => this.#ownershipDecision(id));
@@ -4842,7 +4906,7 @@ ${Date.now()}
     let added = 0;
     let parsed;
     try {
-      parsed = JSON.parse(fs11.readFileSync(this.#registryPath, "utf8"));
+      parsed = this.#registry.read();
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "ENOENT") return;
       return;
@@ -4903,7 +4967,7 @@ ${Date.now()}
         ...typeof record.capabilityDigest === "string" ? { capabilityDigest: record.capabilityDigest } : {},
         ...record.validWhile?.version === 1 && typeof record.validWhile.source === "string" ? { validWhile: record.validWhile } : {},
         latestActivationSequence: 0,
-        sessionFile: path13.join(this.#actorRoot, record.id, "session.jsonl"),
+        sessionFile: path16.join(this.#actorRoot, record.id, "session.jsonl"),
         queue: [],
         draining: false,
         messages: [],
@@ -4912,7 +4976,7 @@ ${Date.now()}
         ...typeof record.lastRunId === "string" ? { lastRunId: record.lastRunId } : {}
       };
       if (Array.isArray(record.messages)) {
-        for (const candidate of record.messages.slice(-MESSAGE_HISTORY_LIMIT)) {
+        for (const candidate of record.messages.slice(-ACTOR_MESSAGE_HISTORY_LIMIT)) {
           if (typeof candidate === "object" && candidate !== null && !Array.isArray(candidate) && typeof candidate.id === "string" && typeof candidate.source === "string" && typeof candidate.createdAt === "number") {
             this.#recordMessage(actor, candidate);
           }
@@ -4995,7 +5059,7 @@ ${Date.now()}
       ...actor.lastRunId ? { lastRunId: actor.lastRunId } : {},
       ...actor.lastError ? { lastError: actor.lastError } : {},
       sessionFile: actor.sessionFile,
-      logDir: path13.join(path13.dirname(actor.sessionFile), "runs")
+      logDir: path16.join(path16.dirname(actor.sessionFile), "runs")
     };
   }
   validateDirectMessage(message, data) {
@@ -5042,8 +5106,8 @@ ${Date.now()}
     this.#adoptionPending.add(actor.id);
     try {
       const expectedRootId = actor.rootId;
-      const adopted = await this.#withRegistryLock(() => {
-        const records = this.#registryRecords();
+      const adopted = await this.#registry.withLock(() => {
+        const records = this.#registry.records();
         const current = records.find((record) => record.id === actor.id);
         if (!current || current.rootId !== expectedRootId) return false;
         if (this.#canManageActor?.(actor.id) !== void 0) return false;
@@ -5058,17 +5122,14 @@ ${Date.now()}
         actor.adoptedAt = Date.now();
         actor.updatedAt = Date.now();
         const preserved = records.filter((record) => record.id !== actor.id);
-        atomicWrite2(this.#registryPath, {
-          format: 1,
-          actors: [...preserved, this.#serializedActor(actor)]
-        });
-        this.#registryFingerprint = this.#currentRegistryFingerprint();
+        this.#registry.write([...preserved, this.#serializedActor(actor)]);
+        this.#registryFingerprint = this.#registry.fingerprint();
         return true;
       });
       if (adopted) {
         this.#persistedRoots.set(actor.id, this.#rootId);
       } else {
-        const current = this.#registryRecords().find((record) => record.id === actor.id);
+        const current = this.#registry.records().find((record) => record.id === actor.id);
         if (!current) {
           this.#persistedRoots.delete(actor.id);
         } else if (typeof current.rootId === "string" && current.rootId !== this.#rootId) {
@@ -5166,10 +5227,10 @@ var ActorDirectory = class extends ActorManager {
     delete options.actorRoot;
     delete options.meshCursorPath;
     const cursorPaths = meshCursorPath ? { project: `${meshCursorPath}.project`, session: `${meshCursorPath}.session` } : void 0;
-    if (meshCursorPath && fs12.existsSync(meshCursorPath)) {
+    if (meshCursorPath && fs15.existsSync(meshCursorPath)) {
       for (const cursorPath of Object.values(cursorPaths)) {
         try {
-          if (!fs12.existsSync(cursorPath)) fs12.copyFileSync(meshCursorPath, cursorPath);
+          if (!fs15.existsSync(cursorPath)) fs15.copyFileSync(meshCursorPath, cursorPath);
         } catch {
         }
       }
@@ -5325,7 +5386,7 @@ var ActorDirectory = class extends ActorManager {
 };
 
 // src/lifecycle/broker.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 var subscriptionKey = (id) => FABRIC_LIFECYCLE_SUBSCRIPTION_PREFIX + id;
 var LifecycleBroker = class {
   constructor(mesh, identity, participants, options, deliver) {
@@ -5404,7 +5465,7 @@ var LifecycleBroker = class {
     const now = Date.now();
     const subscription = {
       format: 1,
-      id: randomUUID7().replaceAll("-", ""),
+      id: randomUUID8().replaceAll("-", ""),
       from,
       events,
       to,
@@ -5569,7 +5630,7 @@ var LifecycleBroker = class {
 };
 
 // src/topology/control-plane.ts
-import { createHash as createHash2, randomUUID as randomUUID8 } from "node:crypto";
+import { createHash as createHash2, randomUUID as randomUUID9 } from "node:crypto";
 var CONTROL_TOPIC = "fabric.control.command";
 var ACK_TOPIC = "fabric.control.ack";
 var CONTROL_SEEN_PREFIX = "topology/control-seen/";
@@ -5664,7 +5725,7 @@ var FabricControlPlane = class {
       this.#pollMs * 4,
       Math.min(MAX_CONTROL_TIMEOUT_MS, Math.floor(options.timeoutMs ?? this.#ackTimeoutMs))
     );
-    const commandId = randomUUID8();
+    const commandId = randomUUID9();
     const requestedAt = Date.now();
     let pendingRequest;
     const acceptance = new Promise((resolve, reject) => {
@@ -5756,7 +5817,7 @@ var FabricControlPlane = class {
       to: pending.ownerHostId,
       data: {
         version: 1,
-        commandId: randomUUID8(),
+        commandId: randomUUID9(),
         targetId: pending.targetId,
         operation: "cancel",
         cancelCommandId: commandId,
@@ -6626,4 +6687,4 @@ export {
   agentParticipantRecords,
   actorParticipantRecord
 };
-//# sourceMappingURL=chunk-2NI5YMKK.js.map
+//# sourceMappingURL=chunk-257ES5IL.js.map