@wrongstack/core 0.301.0 → 0.302.2

package/dist/infrastructure/index.js

@@ -13,703 +13,753 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/utils/pid.ts
-function isPidAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  if (pid === process.pid) return true;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    const code = err.code;
-    if (code === "EPERM") return true;
-    return false;
-  }
+// src/session-catalog/protocol.ts
+function encodeSessionCatalogMessage(message) {
+  return `${JSON.stringify(message)}
+`;
 }
-var init_pid = __esm({
-  "src/utils/pid.ts"() {
+var SESSION_CATALOG_PROTOCOL_VERSION, SESSION_CATALOG_MAX_FRAME_CHARS;
+var init_protocol = __esm({
+  "src/session-catalog/protocol.ts"() {
     "use strict";
+    SESSION_CATALOG_PROTOCOL_VERSION = 1;
+    SESSION_CATALOG_MAX_FRAME_CHARS = 4 * 1024 * 1024;
   }
 });
 
-// src/session-registry-atomic-file.ts
-import { randomUUID } from "node:crypto";
-import * as fs6 from "node:fs/promises";
-import { hostname } from "node:os";
+// src/session-catalog/endpoint.ts
+import { createHash as createHash2 } from "node:crypto";
+import * as os3 from "node:os";
 import * as path8 from "node:path";
-function lockOwnerStamp() {
-  return `${HOST_NAME}:${process.pid}`;
-}
-async function maybeUnlinkOwnedLock(lockPath) {
-  const owner = await fs6.readFile(lockPath, "utf8").catch(() => null);
-  if (owner === null || owner.trim() !== lockOwnerStamp()) return;
-  for (let attempt = 0; attempt < 3; attempt++) {
-    try {
-      await fs6.unlink(lockPath);
-      return;
-    } catch {
-      if (attempt < 2) await new Promise((resolve5) => setTimeout(resolve5, 5));
-    }
-  }
-}
-async function breakStaleLock(lockPath) {
-  try {
-    const content = await fs6.readFile(lockPath, "utf8").catch(() => "");
-    const trimmed = content.trim();
-    const colonIdx = trimmed.indexOf(":");
-    if (colonIdx === -1) {
-      const barePid = Number.parseInt(trimmed, 10);
-      if (Number.isInteger(barePid) && barePid > 0 && !isPidAlive(barePid)) {
-        return await breakStaleLockVerified(lockPath, async () => {
-          const reread = await fs6.readFile(lockPath, "utf8").catch(() => "");
-          return reread.trim() === trimmed;
-        });
-      }
-      return await breakStaleLockVerified(lockPath, async () => {
-        const st = await fs6.stat(lockPath);
-        return Date.now() - st.mtimeMs > STALE_LOCK_MS;
-      });
-    }
-    const ownerHost = trimmed.slice(0, colonIdx);
-    const ownerPid = Number.parseInt(trimmed.slice(colonIdx + 1), 10);
-    if (ownerHost === HOST_NAME && Number.isInteger(ownerPid) && ownerPid > 0) {
-      if (isPidAlive(ownerPid)) {
-        const stat5 = await fs6.stat(lockPath);
-        if (Date.now() - stat5.mtimeMs > SAME_HOST_STALE_MS) {
-          return await breakStaleLockVerified(lockPath, async () => {
-            const st = await fs6.stat(lockPath);
-            return Date.now() - st.mtimeMs > SAME_HOST_STALE_MS;
-          });
-        }
-        return false;
-      }
-      return await breakStaleLockVerified(lockPath, async () => {
-        const reread = await fs6.readFile(lockPath, "utf8").catch(() => "");
-        return reread.trim() === trimmed;
-      });
-    }
-    return await breakStaleLockVerified(lockPath, async () => {
-      const st = await fs6.stat(lockPath);
-      return Date.now() - st.mtimeMs > STALE_LOCK_MS;
-    });
-  } catch {
-    return true;
-  }
+function normalizedPath(value) {
+  const resolved = path8.resolve(value);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
-async function breakStaleLockVerified(lockPath, verify) {
-  if (!await verify()) return false;
-  return await breakLockAtomically(lockPath) === true;
+function sessionCatalogProjectServerKey(projectDir) {
+  return createHash2("sha256").update(normalizedPath(projectDir)).digest("hex").slice(0, 24);
 }
-async function breakLockAtomically(lockPath) {
-  const tombstone = `${lockPath}.stale-${randomUUID()}.tmp`;
-  try {
-    await fs6.rename(lockPath, tombstone);
-  } catch {
-    return false;
-  }
-  void fs6.unlink(tombstone).catch(() => void 0);
-  return true;
-}
-async function writeAtomicFile(filePath, registry) {
-  const tmp = path8.join(
-    path8.dirname(filePath),
-    `.${path8.basename(filePath)}.${randomUUID().slice(0, 8)}.tmp`
-  );
-  let tmpPersisted = false;
-  try {
-    const handle = await fs6.open(tmp, "w");
-    try {
-      await handle.writeFile(JSON.stringify(registry, null, 2), "utf8");
-      await handle.sync().catch(() => void 0);
-    } finally {
-      await handle.close();
-    }
-    tmpPersisted = true;
-    try {
-      await fs6.rename(tmp, filePath);
-      tmpPersisted = false;
-    } catch (renameErr) {
-      const code = renameErr?.code;
-      if (code === "EPERM" || code === "EBUSY" || code === "EACCES") {
-        await fs6.copyFile(tmp, filePath);
-        try {
-          const destHandle = await fs6.open(filePath, "r+");
-          try {
-            await destHandle.sync().catch(() => void 0);
-          } finally {
-            await destHandle.close();
-          }
-        } catch {
-        }
-        await fs6.unlink(tmp).catch(() => void 0);
-        tmpPersisted = false;
-      } else {
-        throw renameErr;
-      }
-    }
-  } catch (err) {
-    if (tmpPersisted) await fs6.unlink(tmp).catch(() => void 0);
-    throw err;
+function sessionCatalogProjectServerEndpoint(projectDir) {
+  const key = sessionCatalogProjectServerKey(projectDir);
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\wrongstack-session-catalog-v${SESSION_CATALOG_PROTOCOL_VERSION}-${key}`;
   }
+  return path8.join(os3.tmpdir(), `wssc-v${SESSION_CATALOG_PROTOCOL_VERSION}`, `${key}.sock`);
 }
-async function pruneStaleTempFiles(filePath) {
-  try {
-    const dir = path8.dirname(filePath);
-    const base = path8.basename(filePath);
-    const now = Date.now();
-    const stale = [];
-    for (const name of await fs6.readdir(dir)) {
-      const isTemp = (name.startsWith(`${base}.`) || name.startsWith(`.${base}.`)) && name.endsWith(".tmp");
-      if (!isTemp) continue;
-      const stat5 = await fs6.stat(path8.join(dir, name)).catch(() => null);
-      if (!stat5) continue;
-      if (now - stat5.mtimeMs > STALE_TMP_MS) stale.push({ name, mtimeMs: stat5.mtimeMs });
-    }
-    stale.sort((a, b) => b.mtimeMs - a.mtimeMs);
-    await Promise.all(
-      stale.slice(MAX_STALE_TMP_FILES).map(async ({ name }) => {
-        await fs6.unlink(path8.join(dir, name)).catch(() => void 0);
-      })
-    );
-  } catch {
-  }
+function sessionCatalogProjectServerMetadataPath(projectDir) {
+  return path8.join(projectDir, SESSION_CATALOG_METADATA_FILE);
 }
-var STALE_LOCK_MS, SAME_HOST_STALE_MS, STALE_TMP_MS, MAX_STALE_TMP_FILES, HOST_NAME;
-var init_session_registry_atomic_file = __esm({
-  "src/session-registry-atomic-file.ts"() {
+var SESSION_CATALOG_METADATA_FILE;
+var init_endpoint = __esm({
+  "src/session-catalog/endpoint.ts"() {
     "use strict";
-    init_pid();
-    STALE_LOCK_MS = 1e4;
-    SAME_HOST_STALE_MS = 2 * STALE_LOCK_MS;
-    STALE_TMP_MS = 6e4;
-    MAX_STALE_TMP_FILES = 20;
-    HOST_NAME = hostname();
+    init_protocol();
+    SESSION_CATALOG_METADATA_FILE = ".session-catalog-server.json";
   }
 });
 
-// src/session-registry.ts
-var session_registry_exports = {};
-__export(session_registry_exports, {
-  SessionRegistry: () => SessionRegistry,
-  getSessionRegistry: () => getSessionRegistry,
-  hasSessionRegistry: () => hasSessionRegistry
-});
-import * as fs7 from "node:fs/promises";
+// src/session-catalog/client.ts
+import { spawn } from "node:child_process";
+import * as fs6 from "node:fs";
+import * as net from "node:net";
 import * as path9 from "node:path";
-function sameOwner(entry, owner) {
-  return entry.pid === owner.pid && entry.startedAt === owner.startedAt;
-}
-function parseRegistry(raw) {
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return parsed;
+import { fileURLToPath } from "node:url";
+function locateServer(moduleUrl, exists) {
+  for (const candidate of [
+    "./project-server.js",
+    "../session-catalog/project-server.js",
+    "./session-catalog/project-server.js",
+    "../../dist/session-catalog/project-server.js"
+  ]) {
+    try {
+      const url = new URL(candidate, moduleUrl);
+      if (url.protocol === "file:" && exists(fileURLToPath(url))) return url;
+    } catch {
     }
-  } catch {
   }
-  return {};
+  return null;
 }
-function deriveSessionStatus(agents) {
-  const hasRunning = agents.some((a) => a.status === "running" || a.status === "streaming");
-  const hasWaiting = agents.some((a) => a.status === "waiting_user");
-  const hasError = agents.some((a) => a.status === "error");
-  return hasRunning || hasWaiting || hasError ? "active" : "idle";
+function resolveSessionCatalogDaemonAvailability(moduleUrl = import.meta.url, exists = fs6.existsSync) {
+  if (process.env["WRONGSTACK_SESSION_CATALOG_INLINE"] || process.env["WRONGSTACK_SESSION_CATALOG_SERVER"] === "0")
+    return { kind: "inline-requested" };
+  const url = locateServer(moduleUrl, exists);
+  return url ? { kind: "available", url } : { kind: "missing-build" };
 }
-function getSessionRegistry(globalRoot) {
-  if (!_instance && globalRoot) {
-    _instance = new SessionRegistry(globalRoot);
-  }
-  if (!_instance) {
-    throw new Error("SessionRegistry not initialized. Call getSessionRegistry(globalRoot) first.");
-  }
-  return _instance;
+function resolveSessionCatalogProjectServerUrl(moduleUrl = import.meta.url, exists = fs6.existsSync) {
+  const availability = resolveSessionCatalogDaemonAvailability(moduleUrl, exists);
+  return availability.kind === "available" ? availability.url : null;
+}
+function normalize2(value) {
+  const resolved = path9.resolve(value);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
-function hasSessionRegistry() {
-  return _instance !== null;
+function delay(ms) {
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
 }
-var REGISTRY_FILE, HEARTBEAT_INTERVAL_MS, STALE_TIMEOUT_MS, PID_CHECK_AFTER_MS, CLOSING_GRACE_MS, AGENT_STALE_MS, OWNERSHIP_LOCK_WAIT_MS, OPTIONAL_LOCK_WAIT_MS, LOCK_RETRY_MAX_MS, AGENTS_WRITE_THROTTLE_MS, SessionOwnershipConflictError, SessionRegistryWriteError, TEMP_PRUNE_INTERVAL_MS, pidAlive, SessionRegistry, _instance;
-var init_session_registry = __esm({
-  "src/session-registry.ts"() {
+var CONNECT_TIMEOUT_MS, START_TIMEOUT_MS, CALL_TIMEOUT_MS, MAX_PENDING_REQUESTS, MAX_EVENT_LISTENERS, SessionCatalogProjectClient;
+var init_client = __esm({
+  "src/session-catalog/client.ts"() {
     "use strict";
-    init_session_registry_atomic_file();
-    init_pid();
-    REGISTRY_FILE = "session-registry.json";
-    HEARTBEAT_INTERVAL_MS = 5e3;
-    STALE_TIMEOUT_MS = 3e4;
-    PID_CHECK_AFTER_MS = HEARTBEAT_INTERVAL_MS * 2;
-    CLOSING_GRACE_MS = 15e3;
-    AGENT_STALE_MS = 5 * 6e4;
-    OWNERSHIP_LOCK_WAIT_MS = 8e3;
-    OPTIONAL_LOCK_WAIT_MS = 750;
-    LOCK_RETRY_MAX_MS = 100;
-    AGENTS_WRITE_THROTTLE_MS = 300;
-    SessionOwnershipConflictError = class extends Error {
-    };
-    SessionRegistryWriteError = class extends Error {
-    };
-    TEMP_PRUNE_INTERVAL_MS = STALE_TMP_MS;
-    pidAlive = isPidAlive;
-    SessionRegistry = class {
-      filePath;
-      heartbeatTimer = null;
-      currentSessionId = null;
-      lastTempPruneAt = 0;
-      tempPrunePromise = null;
-      /** Latest agent snapshot not yet written; superseded by newer calls. */
-      pendingAgents = null;
-      /** Shared settle promise for all updateAgents calls coalesced into one trailing write. */
-      pendingAgentsFlush = null;
-      pendingAgentsResolve = null;
-      agentsFlushTimer = null;
-      lastAgentsWriteAt = 0;
-      /**
-       * Last full entry this process registered. Kept so the heartbeat can
-       * re-create our entry if it ever goes missing because the file was reset or
-       * a reader pruned a stale snapshot.
-       */
-      lastEntry = null;
-      ownershipLockWaitMs;
-      constructor(globalRoot, options = {}) {
-        this.filePath = path9.join(globalRoot, REGISTRY_FILE);
-        this.ownershipLockWaitMs = Math.max(0, options.ownershipLockWaitMs ?? OWNERSHIP_LOCK_WAIT_MS);
+    init_endpoint();
+    init_protocol();
+    CONNECT_TIMEOUT_MS = 750;
+    START_TIMEOUT_MS = 1e4;
+    CALL_TIMEOUT_MS = 3e4;
+    MAX_PENDING_REQUESTS = 1024;
+    MAX_EVENT_LISTENERS = 64;
+    SessionCatalogProjectClient = class {
+      constructor(options) {
+        this.options = options;
+        this.endpoint = sessionCatalogProjectServerEndpoint(options.projectDir);
+      }
+      options;
+      endpoint;
+      socket = null;
+      info = null;
+      buffer = "";
+      connecting = null;
+      connectResolve = null;
+      connectReject = null;
+      authToken;
+      nextId = 1;
+      pending = /* @__PURE__ */ new Map();
+      eventListeners = /* @__PURE__ */ new Set();
+      reconnectTimer;
+      explicitlyClosed = false;
+      async call(op, args, options = {}) {
+        await this.ensureConnected(true);
+        return this.request({ type: "request", op, args }, options.timeoutMs ?? CALL_TIMEOUT_MS);
       }
-      // ── Public API ──────────────────────────────────────────────────────────
       /**
-       * Register the current session. Call once on session start.
-       * Starts the heartbeat timer.
+       * Call an already-running project daemon without starting one.
+       *
+       * Cross-project discovery must use this path: observing another project is
+       * never sufficient authority to wake that project's IPC owner.
        */
-      async register(entry) {
-        const full = {
-          ...entry,
-          status: "active",
-          lastHeartbeatAt: (/* @__PURE__ */ new Date()).toISOString(),
-          agentCount: entry.agents?.length ?? 0,
-          agents: entry.agents ?? []
+      async callExisting(op, args, options = {}) {
+        await this.ensureConnected(false);
+        return this.request({ type: "request", op, args }, options.timeoutMs ?? CALL_TIMEOUT_MS);
+      }
+      ping() {
+        return this.call("ping", {}, { timeoutMs: 3e3 });
+      }
+      async subscribe(listener) {
+        if (!this.eventListeners.has(listener) && this.eventListeners.size >= MAX_EVENT_LISTENERS) {
+          throw new Error(`Session Catalog listener limit reached (${MAX_EVENT_LISTENERS})`);
+        }
+        this.explicitlyClosed = false;
+        this.eventListeners.add(listener);
+        try {
+          await this.call("subscribe", {});
+        } catch (error) {
+          this.eventListeners.delete(listener);
+          throw error;
+        }
+        return async () => {
+          this.eventListeners.delete(listener);
+          if (this.eventListeners.size === 0)
+            await this.callExisting("unsubscribe", {}).catch(() => void 0);
         };
-        const existingRegistry = await this.readAndPrune();
-        const currentOwner = existingRegistry[entry.sessionId];
-        if (currentOwner && currentOwner.pid !== entry.pid && pidAlive(currentOwner.pid)) {
-          throw new SessionOwnershipConflictError(
-            `Session ${entry.sessionId} is already open in another running wstack (pid ${currentOwner.pid}).`
-          );
+      }
+      async shutdown(reason) {
+        try {
+          await this.ensureConnected(false);
+        } catch {
+          return { stopped: false };
         }
-        await this.atomicUpdate((registry) => {
-          const now = Date.now();
-          for (const [id, existing] of Object.entries(registry)) {
-            if (existing.pid === entry.pid) {
-              if (id !== entry.sessionId) delete registry[id];
-              continue;
-            }
-            const heartbeatAge = now - new Date(existing.lastHeartbeatAt).getTime();
-            if (heartbeatAge > PID_CHECK_AFTER_MS && !pidAlive(existing.pid)) {
-              delete registry[id];
+        const result = await this.request({ type: "shutdown", ...reason !== void 0 ? { reason } : {} }, 5e3).catch(
+          () => ({ stopped: false })
+        );
+        if (result.stopped) {
+          const metadataPath = sessionCatalogProjectServerMetadataPath(this.options.projectDir);
+          const deadline = Date.now() + 5e3;
+          while (fs6.existsSync(metadataPath) && Date.now() < deadline) await delay(20);
+          if (result.pid && result.pid !== process.pid) {
+            while (Date.now() < deadline) {
+              try {
+                process.kill(result.pid, 0);
+                await delay(20);
+              } catch {
+                break;
+              }
             }
           }
-          const lockedOwner = registry[entry.sessionId];
-          if (lockedOwner && lockedOwner.pid !== entry.pid && pidAlive(lockedOwner.pid)) {
-            throw new SessionOwnershipConflictError(
-              `Session ${entry.sessionId} is already open in another running wstack (pid ${lockedOwner.pid}).`
-            );
-          }
-          registry[entry.sessionId] = full;
-        }, true);
-        this.cancelPendingAgentsFlush();
-        if (this.heartbeatTimer) {
-          clearInterval(this.heartbeatTimer);
-          this.heartbeatTimer = null;
         }
-        this.lastAgentsWriteAt = 0;
-        this.currentSessionId = entry.sessionId;
-        this.lastEntry = full;
-        this.heartbeatTimer = setInterval(() => {
-          void this.heartbeat();
-        }, HEARTBEAT_INTERVAL_MS);
-        if (this.heartbeatTimer.unref) this.heartbeatTimer.unref();
+        return result;
       }
-      /**
-       * Update agent status for the current session. Call on every
-       * significant status change (agent start, tool start, user wait, error).
-       *
-       * Writes are coalesced: the first call in a quiet window writes
-       * immediately; calls arriving within {@link AGENTS_WRITE_THROTTLE_MS} of
-       * the last write collapse into one trailing write carrying the newest
-       * snapshot. The in-memory cache ({@link lastEntry}) is always updated
-       * synchronously, so heartbeat re-inserts never carry stale agents.
-       */
-      async updateAgents(agents) {
-        if (!this.currentSessionId) return;
-        this.pendingAgents = agents;
-        if (this.lastEntry) {
-          this.lastEntry.agents = agents;
-          this.lastEntry.agentCount = agents.length;
-          this.lastEntry.status = deriveSessionStatus(agents);
-          this.lastEntry.lastHeartbeatAt = (/* @__PURE__ */ new Date()).toISOString();
-        }
-        const sinceLastWrite = Date.now() - this.lastAgentsWriteAt;
-        if (!this.agentsFlushTimer && sinceLastWrite >= AGENTS_WRITE_THROTTLE_MS) {
-          await this.writeAgentsSnapshot();
-          return;
-        }
-        if (!this.agentsFlushTimer) {
-          const delay = Math.max(0, AGENTS_WRITE_THROTTLE_MS - sinceLastWrite);
-          this.pendingAgentsFlush = new Promise((resolve5, reject) => {
-            this.pendingAgentsResolve = resolve5;
-            const timer = setTimeout(() => {
-              this.agentsFlushTimer = null;
-              this.pendingAgentsFlush = null;
-              this.pendingAgentsResolve = null;
-              this.writeAgentsSnapshot().then(resolve5, reject);
-            }, delay);
-            if (typeof timer.unref === "function") timer.unref();
-            this.agentsFlushTimer = timer;
+      async close() {
+        this.explicitlyClosed = true;
+        if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = void 0;
+        const socket = this.socket;
+        this.socket = null;
+        this.info = null;
+        if (socket && !socket.destroyed)
+          await new Promise((resolve8) => {
+            socket.once("close", resolve8);
+            socket.end();
           });
-        }
-        await this.pendingAgentsFlush;
       }
-      /** Write the newest pending agent snapshot to the registry file. */
-      async writeAgentsSnapshot() {
-        const agents = this.pendingAgents;
-        const sessionId = this.currentSessionId;
-        const owner = this.lastEntry;
-        if (!agents || !sessionId || !owner || owner.sessionId !== sessionId) return;
-        this.pendingAgents = null;
-        this.lastAgentsWriteAt = Date.now();
-        const status = deriveSessionStatus(agents);
-        const nowIso = (/* @__PURE__ */ new Date()).toISOString();
-        await this.atomicUpdate((registry) => {
-          if (this.currentSessionId !== sessionId || this.lastEntry !== owner) return;
-          let entry = registry[sessionId];
-          if (entry && !sameOwner(entry, owner)) return;
-          if (!entry) {
-            entry = { ...owner };
-            registry[sessionId] = entry;
+      async ensureConnected(spawnIfMissing) {
+        if (this.socket && !this.socket.destroyed && this.info) return;
+        if (this.connecting) return this.connecting;
+        this.connecting = this.connectWithElection(spawnIfMissing).finally(() => {
+          this.connecting = null;
+        });
+        return this.connecting;
+      }
+      async connectWithElection(spawnIfMissing) {
+        const deadline = Date.now() + (spawnIfMissing ? START_TIMEOUT_MS : CONNECT_TIMEOUT_MS);
+        let spawned = false;
+        let lastError = new Error("Session Catalog project server unavailable");
+        while (Date.now() < deadline) {
+          try {
+            await this.connectOnce();
+            return;
+          } catch (error) {
+            lastError = error;
+          }
+          if (!spawnIfMissing) break;
+          if (!spawned) {
+            this.spawnDetached();
+            spawned = true;
           }
-          entry.agents = agents;
-          entry.agentCount = agents.length;
-          entry.status = status;
-          entry.lastHeartbeatAt = nowIso;
+          await delay(75);
+        }
+        throw lastError;
+      }
+      connectOnce() {
+        this.socket?.destroy();
+        this.socket = null;
+        this.info = null;
+        this.authToken = void 0;
+        this.buffer = "";
+        return new Promise((resolve8, reject) => {
+          const socket = net.createConnection(this.endpoint);
+          this.socket = socket;
+          socket.setEncoding("utf8");
+          const timer = setTimeout(() => {
+            reject(new Error("Session Catalog handshake timed out"));
+            socket.destroy();
+          }, CONNECT_TIMEOUT_MS);
+          timer.unref?.();
+          this.connectResolve = () => {
+            clearTimeout(timer);
+            this.connectResolve = null;
+            this.connectReject = null;
+            resolve8();
+          };
+          this.connectReject = (error) => {
+            clearTimeout(timer);
+            this.connectResolve = null;
+            this.connectReject = null;
+            reject(error);
+          };
+          socket.on("data", (chunk) => this.onData(socket, chunk));
+          socket.on("error", (error) => {
+            if (!this.info) this.connectReject?.(error);
+          });
+          socket.on("close", () => this.onClose(socket));
         });
       }
-      /**
-       * Cancel a scheduled trailing agents write (releasing any waiters). Used on
-       * shutdown so a late timer can't resurrect an entry that markClosing() /
-       * unregister() is about to finalize. Returns the snapshot that was pending.
-       */
-      cancelPendingAgentsFlush() {
-        if (this.agentsFlushTimer) {
-          clearTimeout(this.agentsFlushTimer);
-          this.agentsFlushTimer = null;
+      currentAuthToken() {
+        if (this.authToken === void 0) {
+          try {
+            const parsed = JSON.parse(
+              fs6.readFileSync(sessionCatalogProjectServerMetadataPath(this.options.projectDir), "utf8")
+            );
+            if (typeof parsed.authToken === "string" && parsed.authToken)
+              this.authToken = parsed.authToken;
+          } catch {
+          }
         }
-        this.pendingAgentsResolve?.();
-        this.pendingAgentsResolve = null;
-        this.pendingAgentsFlush = null;
-        const pending = this.pendingAgents;
-        this.pendingAgents = null;
-        return pending;
+        return this.authToken;
       }
-      /**
-       * Mark the session as closing. Called during shutdown.
-       * Stops the heartbeat timer.
-       */
-      async markClosing() {
-        if (this.heartbeatTimer) {
-          clearInterval(this.heartbeatTimer);
-          this.heartbeatTimer = null;
+      request(message, timeoutMs) {
+        const socket = this.socket;
+        if (!socket || socket.destroyed)
+          return Promise.reject(new Error("Session Catalog connection is unavailable"));
+        const id = this.nextId++;
+        if (this.pending.size >= MAX_PENDING_REQUESTS) {
+          return Promise.reject(
+            new Error(`Session Catalog pending request limit reached (${MAX_PENDING_REQUESTS})`)
+          );
         }
-        if (!this.currentSessionId) return;
-        const sessionId = this.currentSessionId;
-        const owner = this.lastEntry;
-        if (!owner) return;
-        const pendingAgents = this.cancelPendingAgentsFlush();
-        await this.atomicUpdate((registry) => {
-          const entry = registry[sessionId];
-          if (!entry || !sameOwner(entry, owner)) return;
-          if (pendingAgents) {
-            entry.agents = pendingAgents;
-            entry.agentCount = pendingAgents.length;
-          }
-          entry.status = "closing";
-          entry.lastHeartbeatAt = (/* @__PURE__ */ new Date()).toISOString();
+        const encoded = encodeSessionCatalogMessage({
+          ...message,
+          id,
+          authToken: this.currentAuthToken()
+        });
+        if (encoded.length > SESSION_CATALOG_MAX_FRAME_CHARS)
+          return Promise.reject(new Error("Session Catalog request exceeded frame limit"));
+        return new Promise((resolve8, reject) => {
+          const timer = setTimeout(() => {
+            const pending = this.pending.get(id);
+            if (!pending) return;
+            this.pending.delete(id);
+            pending.reject(
+              new Error(
+                `Session Catalog ${message.type === "request" ? message.op : message.type} timed out`
+              )
+            );
+          }, timeoutMs);
+          timer.unref?.();
+          this.pending.set(id, { resolve: resolve8, reject, timer });
+          socket.write(encoded);
         });
       }
-      /**
-       * Remove the current session from the registry. Call on clean exit.
-       */
-      async unregister() {
-        if (this.heartbeatTimer) {
-          clearInterval(this.heartbeatTimer);
-          this.heartbeatTimer = null;
+      onData(socket, chunk) {
+        if (socket !== this.socket) return;
+        this.buffer += chunk;
+        if (this.buffer.length > SESSION_CATALOG_MAX_FRAME_CHARS) {
+          socket.destroy(new Error("Session Catalog response exceeded frame limit"));
+          return;
         }
-        if (!this.currentSessionId) return;
-        this.cancelPendingAgentsFlush();
-        const sid = this.currentSessionId;
-        const owner = this.lastEntry;
-        this.currentSessionId = null;
-        this.lastEntry = null;
-        await this.atomicUpdate((registry) => {
-          const entry = registry[sid];
-          if (owner && entry && sameOwner(entry, owner)) {
-            delete registry[sid];
+        while (true) {
+          const newline = this.buffer.indexOf("\n");
+          if (newline < 0) return;
+          const line = this.buffer.slice(0, newline);
+          this.buffer = this.buffer.slice(newline + 1);
+          if (!line) continue;
+          try {
+            this.onMessage(JSON.parse(line));
+          } catch {
+            socket.destroy(new Error("Invalid Session Catalog response"));
+            return;
           }
-        });
+        }
       }
-      /**
-       * List all non-stale sessions. Prunes stale entries automatically.
-       */
-      async list() {
-        const registry = await this.readAndPrune();
-        return Object.values(registry);
+      onMessage(message) {
+        if (message.type === "hello") {
+          if (message.protocolVersion !== SESSION_CATALOG_PROTOCOL_VERSION) {
+            this.connectReject?.(
+              new Error(
+                `Session Catalog protocol mismatch: client=${SESSION_CATALOG_PROTOCOL_VERSION}, server=${message.protocolVersion}`
+              )
+            );
+            this.socket?.destroy();
+            return;
+          }
+          if (normalize2(message.projectDir) !== normalize2(this.options.projectDir) || normalize2(message.projectRoot) !== normalize2(this.options.projectRoot)) {
+            this.connectReject?.(new Error("Session Catalog project identity mismatch"));
+            this.socket?.destroy();
+            return;
+          }
+          this.info = message;
+          this.connectResolve?.();
+          return;
+        }
+        if (message.type === "event") {
+          for (const listener of this.eventListeners) {
+            try {
+              listener(message.event);
+            } catch {
+            }
+          }
+          return;
+        }
+        const pending = this.pending.get(message.id);
+        if (!pending) return;
+        this.pending.delete(message.id);
+        clearTimeout(pending.timer);
+        if (message.ok) pending.resolve(message.result);
+        else {
+          const error = new Error(message.error);
+          if (message.errorName) error.name = message.errorName;
+          pending.reject(error);
+        }
       }
-      /**
-       * Get a single session entry by ID. Returns undefined if not found or stale.
-       */
-      async get(sessionId) {
-        const registry = await this.readAndPrune();
-        return registry[sessionId];
+      onClose(socket) {
+        if (socket !== this.socket) return;
+        this.socket = null;
+        this.info = null;
+        this.authToken = void 0;
+        const error = new Error("Session Catalog connection closed");
+        this.connectReject?.(error);
+        this.connectResolve = null;
+        this.connectReject = null;
+        for (const pending of this.pending.values()) {
+          clearTimeout(pending.timer);
+          pending.reject(error);
+        }
+        this.pending.clear();
+        this.scheduleSubscriptionReconnect();
       }
-      /**
-       * List all sessions for a specific project (by slug).
-       */
-      async listByProject(projectSlug2) {
-        const all = await this.list();
-        return all.filter((e) => e.projectSlug === projectSlug2);
+      scheduleSubscriptionReconnect() {
+        if (this.explicitlyClosed || this.eventListeners.size === 0 || this.reconnectTimer) return;
+        this.reconnectTimer = setTimeout(() => {
+          this.reconnectTimer = void 0;
+          void this.call("subscribe", {}).catch(() => this.scheduleSubscriptionReconnect());
+        }, 250);
+        this.reconnectTimer.unref?.();
       }
-      /**
-       * Return the registry file path. Useful for WebUI to watch/read.
-       */
-      get registryPath() {
-        return this.filePath;
+      spawnDetached() {
+        const url = resolveSessionCatalogProjectServerUrl();
+        if (!url) throw new Error("Built Session Catalog project server is unavailable");
+        const child = spawn(
+          process.execPath,
+          [
+            fileURLToPath(url),
+            "--project-dir",
+            this.options.projectDir,
+            "--project-root",
+            this.options.projectRoot
+          ],
+          { detached: true, stdio: "ignore", windowsHide: true, env: process.env }
+        );
+        child.unref();
       }
-      // ── Internal ────────────────────────────────────────────────────────────
-      async heartbeat() {
-        if (!this.currentSessionId) return;
-        try {
-          const sessionId = this.currentSessionId;
-          const owner = this.lastEntry;
-          if (!owner || owner.sessionId !== sessionId) return;
-          const nowIso = (/* @__PURE__ */ new Date()).toISOString();
-          await this.atomicUpdate((registry) => {
-            if (this.currentSessionId !== sessionId || this.lastEntry !== owner) return;
-            const entry = registry[sessionId];
-            if (entry) {
-              if (!sameOwner(entry, owner)) return;
-              entry.lastHeartbeatAt = nowIso;
-              if (entry.status !== "closing") {
-                const hasRunning = (entry.agents ?? []).some(
-                  (a) => a.status === "running" || a.status === "streaming"
-                );
-                entry.status = hasRunning ? "active" : "idle";
-              }
-              return;
+    };
+  }
+});
+
+// src/session-catalog/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  ProjectSessionRegistry: () => ProjectSessionRegistry,
+  getProjectSessionRegistry: () => getProjectSessionRegistry,
+  hasProjectSessionRegistry: () => hasProjectSessionRegistry
+});
+import { randomUUID } from "node:crypto";
+import * as fs7 from "node:fs/promises";
+import * as path10 from "node:path";
+function getProjectSessionRegistry(globalRoot) {
+  const key = globalRoot !== void 0 ? path10.resolve(globalRoot) : lastRegistryKey;
+  if (!key)
+    throw new Error("SessionRegistry not initialized. Call getSessionRegistry(globalRoot) first.");
+  let registry = registries.get(key);
+  if (!registry) {
+    if (registries.size >= MAX_GLOBAL_ROOTS) {
+      const idle = [...registries.entries()].find(([, candidate]) => !candidate.ownsSession());
+      if (!idle)
+        throw new Error(`Session Registry global-root limit reached (${MAX_GLOBAL_ROOTS})`);
+      registries.delete(idle[0]);
+      void idle[1].dispose();
+    }
+    registry = new ProjectSessionRegistry(key);
+    registries.set(key, registry);
+  } else {
+    registries.delete(key);
+    registries.set(key, registry);
+  }
+  lastRegistryKey = key;
+  return registry;
+}
+function hasProjectSessionRegistry(globalRoot) {
+  if (globalRoot === void 0) return registries.size > 0;
+  return registries.has(path10.resolve(globalRoot));
+}
+var HEARTBEAT_INTERVAL_MS, AGENT_WRITE_THROTTLE_MS, MAX_PROJECT_CLIENTS, MAX_GLOBAL_ROOTS, ProjectSessionRegistry, registries, lastRegistryKey;
+var init_registry = __esm({
+  "src/session-catalog/registry.ts"() {
+    "use strict";
+    init_client();
+    init_endpoint();
+    HEARTBEAT_INTERVAL_MS = 5e3;
+    AGENT_WRITE_THROTTLE_MS = 300;
+    MAX_PROJECT_CLIENTS = 128;
+    MAX_GLOBAL_ROOTS = 16;
+    ProjectSessionRegistry = class {
+      constructor(globalRoot) {
+        this.globalRoot = globalRoot;
+      }
+      globalRoot;
+      instanceId = randomUUID();
+      clients = /* @__PURE__ */ new Map();
+      current;
+      heartbeatTimer;
+      agentRevision = 0;
+      pendingAgents;
+      agentTimer;
+      lastAgentWriteAt = 0;
+      bindingKey(projectDir) {
+        const resolved = path10.resolve(projectDir);
+        return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+      }
+      async closeBinding(binding) {
+        if (this.current?.binding === binding) return;
+        const key = this.bindingKey(binding.projectDir);
+        if (this.clients.get(key) === binding) this.clients.delete(key);
+        await binding.client.close();
+      }
+      binding(projectSlug2, projectRoot) {
+        const projectDir = path10.join(this.globalRoot, "projects", projectSlug2);
+        const key = this.bindingKey(projectDir);
+        let binding = this.clients.get(key);
+        if (!binding) {
+          if (this.clients.size >= MAX_PROJECT_CLIENTS) {
+            const oldest = [...this.clients.entries()].find(
+              ([, candidate]) => candidate !== this.current?.binding
+            );
+            if (oldest) {
+              this.clients.delete(oldest[0]);
+              void oldest[1].client.close();
             }
-            registry[sessionId] = { ...owner, lastHeartbeatAt: nowIso };
-          });
-        } catch {
+          }
+          binding = {
+            projectDir,
+            projectRoot: path10.resolve(projectRoot),
+            client: new SessionCatalogProjectClient({ projectDir, projectRoot })
+          };
+          this.clients.set(key, binding);
+        } else {
+          this.clients.delete(key);
+          this.clients.set(key, binding);
         }
+        return binding;
       }
-      async readAndPrune() {
+      fullEntry(entry) {
+        const agents = entry.agents ?? [];
+        return {
+          ...entry,
+          status: agents.some((agent) => agent.status !== "idle") ? "active" : "idle",
+          lastHeartbeatAt: (/* @__PURE__ */ new Date()).toISOString(),
+          agentCount: agents.length,
+          agents
+        };
+      }
+      async register(entry) {
+        const full = this.fullEntry(entry);
+        if (this.current?.entry.sessionId === full.sessionId && this.current.entry.pid === full.pid) {
+          this.current.entry = full;
+          this.current.credential = await this.current.binding.client.call("heartbeat", {
+            credential: this.current.credential,
+            status: full.status
+          });
+          return;
+        }
+        const nextBinding = this.binding(full.projectSlug, full.projectRoot);
+        let nextCredential;
         try {
-          const raw = await fs7.readFile(this.filePath, "utf8");
-          const registry = parseRegistry(raw);
-          const observed = new Map(
-            Object.entries(registry).map(([id, entry]) => [
-              id,
-              { pid: entry.pid, lastHeartbeatAt: entry.lastHeartbeatAt }
-            ])
-          );
-          const now = Date.now();
-          let pruned = false;
-          for (const [id, entry] of Object.entries(registry)) {
-            const heartbeatAt = Date.parse(entry.lastHeartbeatAt);
-            if (!Number.isFinite(heartbeatAt)) {
-              delete registry[id];
-              pruned = true;
-              continue;
-            }
-            const heartbeatAge = now - heartbeatAt;
-            const agents = Array.isArray(entry.agents) ? entry.agents : [];
-            const liveAgents = agents.filter((agent) => {
-              if (agent.id === "leader") return true;
-              const lastActivityAt = Date.parse(agent.lastActivityAt);
-              return Number.isFinite(lastActivityAt) && now - lastActivityAt <= AGENT_STALE_MS;
-            });
-            if (liveAgents.length !== agents.length || entry.agentCount !== liveAgents.length) {
-              entry.agents = liveAgents;
-              entry.agentCount = liveAgents.length;
-              pruned = true;
-            }
-            if (entry.status === "closing" && heartbeatAge > CLOSING_GRACE_MS) {
-              if (!pidAlive(entry.pid)) {
-                delete registry[id];
-                pruned = true;
-              }
-              continue;
-            }
-            if (heartbeatAge > PID_CHECK_AFTER_MS && !pidAlive(entry.pid)) {
-              delete registry[id];
-              pruned = true;
-              continue;
-            }
-            if (heartbeatAge <= STALE_TIMEOUT_MS) continue;
-            if (entry.status !== "lost") {
-              entry.status = "lost";
-              pruned = true;
-            }
-          }
-          if (pruned) {
-            await this.atomicUpdate((current) => {
-              for (const [id, version] of observed) {
-                const latest = current[id];
-                if (!latest || latest.pid !== version.pid || latest.lastHeartbeatAt !== version.lastHeartbeatAt) {
-                  continue;
-                }
-                const next = registry[id];
-                if (next) current[id] = next;
-                else delete current[id];
-              }
-            });
-          }
-          return registry;
-        } catch {
-          return {};
+          nextCredential = await nextBinding.client.call("claim_new", {
+            entry: full,
+            ownerInstanceId: this.instanceId
+          });
+        } catch (error) {
+          await this.closeBinding(nextBinding).catch(() => void 0);
+          throw error;
+        }
+        const previous = this.current;
+        this.current = { binding: nextBinding, credential: nextCredential, entry: full };
+        this.agentRevision = 0;
+        this.cancelAgentTimer();
+        this.startHeartbeat();
+        if (previous) {
+          await previous.binding.client.call("release", { credential: previous.credential }).catch(() => void 0);
+          if (previous.binding !== nextBinding) await this.closeBinding(previous.binding);
         }
       }
-      async atomicUpdate(fn, required = false) {
-        const lockPath = `${this.filePath}.lock`;
-        const waitBudgetMs = required ? this.ownershipLockWaitMs : OPTIONAL_LOCK_WAIT_MS;
-        const deadline = Date.now() + waitBudgetMs;
-        let attempt = 0;
+      /** Reserve before transcript hydration; activation swaps ownership only after the writer opened. */
+      async reserveResume(target) {
+        const binding = this.binding(target.projectSlug, target.projectRoot);
+        let reservation;
         try {
-          await fs7.mkdir(path9.dirname(this.filePath), { recursive: true });
-          await this.maybePruneStaleTempFiles();
-        } catch (err) {
-          if (required) {
-            throw new SessionRegistryWriteError(
-              `Session registry ownership update failed: ${err instanceof Error ? err.message : String(err)}`
-            );
-          }
-          return;
+          reservation = await binding.client.call("reserve_resume", {
+            targetSessionId: target.sessionId,
+            requesterInstanceId: this.instanceId,
+            ...this.current ? { currentSessionId: this.current.entry.sessionId } : {}
+          });
+        } catch (error) {
+          await this.closeBinding(binding).catch(() => void 0);
+          throw error;
         }
-        while (true) {
-          try {
-            let lockHandle = await fs7.open(lockPath, "wx").catch(() => null);
-            if (!lockHandle) {
-              if (await breakStaleLock(lockPath)) {
-                lockHandle = await fs7.open(lockPath, "wx").catch(() => null);
-              }
-              if (!lockHandle) {
-                const remainingMs = deadline - Date.now();
-                if (remainingMs <= 0) break;
-                const retryDelayMs = Math.min(LOCK_RETRY_MAX_MS, 20 * (attempt + 1));
-                await new Promise(
-                  (resolve5) => setTimeout(resolve5, Math.min(retryDelayMs, remainingMs))
-                );
-                attempt += 1;
-                continue;
-              }
+        let settled = false;
+        return {
+          reservation,
+          activate: async (registration) => {
+            if (settled) throw new Error("Resume reservation is already settled");
+            const entry = this.fullEntry(registration);
+            const credential = await binding.client.call("activate_reservation", {
+              reservation,
+              entry
+            });
+            const previous = this.current;
+            this.current = { binding, credential, entry };
+            settled = true;
+            this.agentRevision = 0;
+            this.cancelAgentTimer();
+            this.startHeartbeat();
+            if (previous) {
+              await previous.binding.client.call("release", { credential: previous.credential }).catch(() => void 0);
+              if (previous.binding !== binding) await this.closeBinding(previous.binding);
             }
-            let stampFailed = false;
+          },
+          cancel: async () => {
+            if (settled) return;
+            settled = true;
             try {
-              let stamped = false;
-              for (let stampAttempt = 0; stampAttempt < 3 && !stamped; stampAttempt++) {
-                try {
-                  await lockHandle.writeFile(lockOwnerStamp());
-                  stamped = true;
-                } catch {
-                  if (stampAttempt < 2) await new Promise((resolve5) => setTimeout(resolve5, 5));
-                }
-              }
-              if (!stamped) {
-                stampFailed = true;
-                throw new Error("failed to stamp session-registry lock owner");
-              }
-              const raw = await fs7.readFile(this.filePath, "utf8").catch(() => "{}");
-              const registry = parseRegistry(raw);
-              fn(registry);
-              await this.writeAtomicWithRetry(registry);
-              return;
+              await binding.client.call("cancel_reservation", {
+                reservationId: reservation.reservationId,
+                requesterInstanceId: this.instanceId
+              }).catch(() => void 0);
             } finally {
-              await lockHandle.close().catch(() => void 0);
-              if (stampFailed) {
-                await fs7.unlink(lockPath).catch(() => void 0);
-              } else {
-                await maybeUnlinkOwnedLock(lockPath);
-              }
-            }
-          } catch (err) {
-            if (err instanceof SessionOwnershipConflictError) throw err;
-            if (required) {
-              throw new SessionRegistryWriteError(
-                `Session registry ownership update failed: ${err instanceof Error ? err.message : String(err)}`
-              );
+              await this.closeBinding(binding).catch(() => void 0);
             }
-            return;
           }
+        };
+      }
+      async updateAgents(agents) {
+        if (!this.current) return;
+        this.pendingAgents = agents;
+        this.current.entry = {
+          ...this.current.entry,
+          agents,
+          agentCount: agents.length,
+          status: agents.some((agent) => agent.status !== "idle") ? "active" : "idle",
+          lastHeartbeatAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const elapsed = Date.now() - this.lastAgentWriteAt;
+        if (!this.agentTimer && elapsed >= AGENT_WRITE_THROTTLE_MS) {
+          await this.flushAgents();
+          return;
         }
-        if (required) {
-          throw new SessionRegistryWriteError(
-            `Session registry ownership update failed: lock remained busy for ${waitBudgetMs}ms at ${lockPath}`
+        if (!this.agentTimer) {
+          this.agentTimer = setTimeout(
+            () => {
+              this.agentTimer = void 0;
+              void this.flushAgents();
+            },
+            Math.max(0, AGENT_WRITE_THROTTLE_MS - elapsed)
           );
+          this.agentTimer.unref?.();
         }
       }
-      async writeAtomicLocked(registry) {
-        await this.writeAtomicFile(registry);
+      async flushAgents() {
+        const agents = this.pendingAgents;
+        const current = this.current;
+        if (!agents || !current) return;
+        this.pendingAgents = void 0;
+        this.lastAgentWriteAt = Date.now();
+        const revision = ++this.agentRevision;
+        await current.binding.client.call("publish_agents", {
+          credential: current.credential,
+          revision,
+          agents
+        });
       }
-      /**
-       * Windows-safe wrapper around {@link writeAtomicLocked}. Retries on the small
-       * set of transient OS errors that occur when an antivirus scan, an indexing
-       * service, or a peer process opens the destination file for read at the
-       * same instant rename/copy tries to land. Retries are short and bounded so
-       * the heartbeat never wedges; the per-call cap is well below the 5 s
-       * heartbeat interval.
-       *
-       * Errors that look persistent (ENOENT, JSON.parse-style, anything other than
-       * the well-known transient codes) are rethrown immediately so the original
-       * failure isn't masked.
-       */
-      async writeAtomicWithRetry(registry) {
-        const transientCodes = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ETXTBSY", "ENOTEMPTY"]);
-        const maxAttempts = 5;
-        let lastErr;
-        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      async markClosing() {
+        this.stopHeartbeat();
+        this.cancelAgentTimer();
+        if (this.current)
+          await this.current.binding.client.call("mark_closing", {
+            credential: this.current.credential
+          });
+      }
+      async unregister() {
+        this.stopHeartbeat();
+        this.cancelAgentTimer();
+        const current = this.current;
+        this.current = void 0;
+        if (current) {
           try {
-            await this.writeAtomicLocked(registry);
-            return;
-          } catch (err) {
-            lastErr = err;
-            const code = err?.code;
-            if (!transientCodes.has(String(code ?? "")) || attempt === maxAttempts) {
-              throw err;
-            }
-            const delayMs = Math.min(80, 5 * attempt);
-            await new Promise((resolve5) => setTimeout(resolve5, delayMs));
+            await current.binding.client.call("release", { credential: current.credential });
+          } finally {
+            await this.closeBinding(current.binding);
           }
         }
-        throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
       }
-      async maybePruneStaleTempFiles() {
-        if (this.tempPrunePromise) {
-          await this.tempPrunePromise;
-          return;
+      async list() {
+        const projectsDir = path10.join(this.globalRoot, "projects");
+        let directories = [];
+        try {
+          directories = (await fs7.readdir(projectsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).slice(0, 1e3).map((entry) => entry.name);
+        } catch {
+          return [];
+        }
+        const snapshots = await Promise.all(
+          directories.map(async (slug) => {
+            const projectDir = path10.join(projectsDir, slug);
+            let client;
+            try {
+              const metadata = JSON.parse(
+                await fs7.readFile(sessionCatalogProjectServerMetadataPath(projectDir), "utf8")
+              );
+              if (typeof metadata.projectRoot !== "string" || !metadata.projectRoot) return [];
+              client = new SessionCatalogProjectClient({
+                projectDir,
+                projectRoot: metadata.projectRoot
+              });
+              return await client.callExisting("list_live", {});
+            } catch {
+              return [];
+            } finally {
+              await client?.close().catch(() => void 0);
+            }
+          })
+        );
+        return snapshots.flat();
+      }
+      async listByProject(projectSlug2) {
+        const current = this.current;
+        if (current && path10.basename(current.binding.projectDir) === projectSlug2) {
+          return current.binding.client.call("list_live", {}).catch(() => []);
         }
-        const now = Date.now();
-        if (now - this.lastTempPruneAt < TEMP_PRUNE_INTERVAL_MS) return;
-        this.lastTempPruneAt = now;
-        this.tempPrunePromise = this.pruneStaleTempFiles();
+        const projectDir = path10.join(this.globalRoot, "projects", projectSlug2);
+        let client;
         try {
-          await this.tempPrunePromise;
+          const metadata = JSON.parse(
+            await fs7.readFile(sessionCatalogProjectServerMetadataPath(projectDir), "utf8")
+          );
+          if (typeof metadata.projectRoot !== "string") return [];
+          client = new SessionCatalogProjectClient({ projectDir, projectRoot: metadata.projectRoot });
+          return await client.callExisting("list_live", {}).catch(() => []);
+        } catch {
+          return [];
         } finally {
-          this.tempPrunePromise = null;
+          await client?.close().catch(() => void 0);
         }
       }
-      async writeAtomicFile(registry) {
-        await writeAtomicFile(this.filePath, registry);
+      async get(sessionId) {
+        return (await this.list()).find((entry) => entry.sessionId === sessionId);
       }
-      async pruneStaleTempFiles() {
-        await pruneStaleTempFiles(this.filePath);
+      subscribeProject(projectSlug2, projectRoot, listener) {
+        const binding = this.binding(projectSlug2, projectRoot);
+        return binding.client.subscribe(listener).then((unsubscribe) => async () => {
+          await unsubscribe();
+          await this.closeBinding(binding);
+        });
+      }
+      get registryPath() {
+        return path10.join(this.globalRoot, "projects");
+      }
+      async dispose() {
+        await this.unregister().catch(() => void 0);
+        await Promise.all([...this.clients.values()].map((binding) => binding.client.close()));
+        this.clients.clear();
+      }
+      /** Whether this facade currently owns a live session lease. */
+      ownsSession() {
+        return this.current !== void 0;
+      }
+      startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+          void this.heartbeat();
+        }, HEARTBEAT_INTERVAL_MS);
+        this.heartbeatTimer.unref?.();
+      }
+      stopHeartbeat() {
+        if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = void 0;
+      }
+      cancelAgentTimer() {
+        if (this.agentTimer) clearTimeout(this.agentTimer);
+        this.agentTimer = void 0;
+        this.pendingAgents = void 0;
+      }
+      async heartbeat() {
+        const current = this.current;
+        if (!current) return;
+        try {
+          const credential = await current.binding.client.call("heartbeat", {
+            credential: current.credential,
+            status: current.entry.status
+          });
+          if (this.current === current) current.credential = credential;
+        } catch {
+        }
       }
     };
-    _instance = null;
+    registries = /* @__PURE__ */ new Map();
   }
 });
 
@@ -757,7 +807,7 @@ function envFlag(value) {
   return !/^(0|false|no|off)$/i.test(value.trim());
 }
 var COLOR = isColorTty();
-var wrap = (open3, close) => (s) => COLOR ? `\x1B[${open3}m${s}\x1B[${close}m` : s;
+var wrap = (open, close) => (s) => COLOR ? `\x1B[${open}m${s}\x1B[${close}m` : s;
 var color = {
   reset: wrap("0", "0"),
   bold: wrap("1", "22"),
@@ -2143,8 +2193,8 @@ var contextManagerTool = createContextManagerTool();
 
 // src/boot.ts
 import * as fs8 from "node:fs/promises";
-import * as os3 from "node:os";
-import * as path10 from "node:path";
+import * as os4 from "node:os";
+import * as path11 from "node:path";
 
 // src/security/secret-vault.ts
 import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "node:crypto";
@@ -2525,8 +2575,8 @@ function checkKeyFilePermissions(keyFile, opts) {
   if (process.platform === "win32") return;
   const warn = opts?.warn ?? ((msg) => console.warn(msg));
   try {
-    const stat5 = fs2.statSync(keyFile);
-    const actualMode = stat5.mode & 511;
+    const stat4 = fs2.statSync(keyFile);
+    const actualMode = stat4.mode & 511;
     if (actualMode !== KEY_FILE_MODE) {
       void restrictFilePermissions(keyFile, {
         label: "secret-vault",
@@ -3583,8 +3633,8 @@ var IN_PROJECT_DENIED_PATHS = [
     reason: "The other half of the filesystem confinement switch."
   }
 ];
-function deleteNestedPath(target, path11) {
-  const segments = path11.split(".");
+function deleteNestedPath(target, path12) {
+  const segments = path12.split(".");
   const last = segments[segments.length - 1];
   if (last === void 0) return false;
   let cursor = target;
@@ -3641,16 +3691,16 @@ function assertInProjectAllowListComplete() {
     );
   }
   const orphanedPaths = IN_PROJECT_DENIED_PATHS.filter(
-    ({ path: path11 }) => !IN_PROJECT_ALLOWED_KEYS.has(path11.split(".")[0] ?? "")
-  ).map(({ path: path11 }) => path11);
+    ({ path: path12 }) => !IN_PROJECT_ALLOWED_KEYS.has(path12.split(".")[0] ?? "")
+  ).map(({ path: path12 }) => path12);
   if (orphanedPaths.length > 0) {
     problems.push(
       `IN_PROJECT_DENIED_PATHS entr(ies) whose top-level parent is not allowed: ` + orphanedPaths.join(", ") + ". The parent is already stripped wholesale, so the nested denial is dead \u2014 remove it."
     );
   }
   const malformedPaths = IN_PROJECT_DENIED_PATHS.filter(
-    ({ path: path11 }) => path11.split(".").length < 2 || path11.split(".").some((s) => s.length === 0)
-  ).map(({ path: path11 }) => path11);
+    ({ path: path12 }) => path12.split(".").length < 2 || path12.split(".").some((s) => s.length === 0)
+  ).map(({ path: path12 }) => path12);
   if (malformedPaths.length > 0) {
     problems.push(
       `IN_PROJECT_DENIED_PATHS entr(ies) are not dotted nested paths: ` + malformedPaths.join(", ") + ". Top-level keys belong in KNOWN_DENIED_IN_PROJECT instead."
@@ -3678,8 +3728,8 @@ function stripUnsafeInProjectFields(inProject, sourcePath, warn = (msg) => conso
     }
     stripped.push(k);
   }
-  for (const { path: path11 } of IN_PROJECT_DENIED_PATHS) {
-    if (deleteNestedPath(out, path11)) stripped.push(path11);
+  for (const { path: path12 } of IN_PROJECT_DENIED_PATHS) {
+    if (deleteNestedPath(out, path12)) stripped.push(path12);
   }
   if (stripped.length > 0) {
     warn(
@@ -4288,8 +4338,8 @@ var DefaultConfigLoader = class _DefaultConfigLoader {
     const t0 = Date.now();
     let mtimeMs = null;
     try {
-      const stat5 = await fs5.stat(file);
-      mtimeMs = stat5.mtimeMs;
+      const stat4 = await fs5.stat(file);
+      mtimeMs = stat4.mtimeMs;
       const cached = this.jsonCache.get(file);
       if (cached && cached.mtimeMs === mtimeMs) {
         return structuredClone(cached.value);
@@ -4588,11 +4638,11 @@ async function bootConfig(options = {}) {
     loadSyncConfig = true,
     skipIdentityValidation = false
   } = options;
-  const cwd = typeof flags["cwd"] === "string" ? path10.resolve(flags["cwd"]) : process.cwd();
+  const cwd = typeof flags["cwd"] === "string" ? path11.resolve(flags["cwd"]) : process.cwd();
   const pathResolver = new DefaultPathResolver(cwd);
   const projectRoot = pathResolver.projectRoot;
   const projectIdentityRoot = canonicalProjectRoot(projectRoot);
-  const userHome = os3.homedir();
+  const userHome = os4.homedir();
   const wpaths = resolveWstackPaths({ projectRoot });
   assertProjectRootOutsideStateDir(projectRoot, wpaths.globalRoot);
   await fs8.mkdir(wpaths.globalRoot, { recursive: true });
@@ -4701,8 +4751,8 @@ async function bootConfig(options = {}) {
   }
   const logger = new DefaultLogger({ level: config.log?.level ?? "info", file: wpaths.logFile });
   try {
-    const { getSessionRegistry: getSessionRegistry2 } = await Promise.resolve().then(() => (init_session_registry(), session_registry_exports));
-    getSessionRegistry2(wpaths.globalRoot);
+    const { getProjectSessionRegistry: getProjectSessionRegistry2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+    getProjectSessionRegistry2(wpaths.globalRoot);
   } catch {
   }
   return {
@@ -4791,7 +4841,7 @@ async function migrateLegacyConfig(wpaths) {
   } catch (err) {
     if (err.code !== "ENOENT") return;
   }
-  await fs8.mkdir(path10.dirname(profileFp), { recursive: true });
+  await fs8.mkdir(path11.dirname(profileFp), { recursive: true });
   const profileContent = { ...result.value };
   delete profileContent["activeProfile"];
   await atomicWrite(profileFp, JSON.stringify(profileContent, null, 2), { mode: 384 });
@@ -4803,57 +4853,57 @@ async function migrateLegacyConfig(wpaths) {
 }
 var PROFILE_STATE_PAIRS = [
   {
-    globalSrc: (w) => path10.join(w.globalRoot, "statusline.json"),
+    globalSrc: (w) => path11.join(w.globalRoot, "statusline.json"),
     profileDst: (w, n) => w.profileStatuslineConfig(n)
   },
   {
-    globalSrc: (w) => path10.join(w.globalRoot, "mode.json"),
+    globalSrc: (w) => path11.join(w.globalRoot, "mode.json"),
     profileDst: (w, n) => w.profileModeConfig(n)
   },
   {
-    globalSrc: (w) => path10.join(w.globalRoot, "provider-status.json"),
+    globalSrc: (w) => path11.join(w.globalRoot, "provider-status.json"),
     profileDst: (w, n) => w.profileProviderStatus(n)
   },
   {
-    globalSrc: (w) => path10.join(w.globalRoot, "update-cache.json"),
+    globalSrc: (w) => path11.join(w.globalRoot, "update-cache.json"),
     profileDst: (w, n) => w.profileUpdateCache(n)
   },
   {
-    globalSrc: (w) => path10.join(w.globalRoot, "memory.md"),
-    profileDst: (w, n) => path10.join(w.profilesDir, n, "memory.md")
+    globalSrc: (w) => path11.join(w.globalRoot, "memory.md"),
+    profileDst: (w, n) => path11.join(w.profilesDir, n, "memory.md")
   },
   {
-    globalSrc: (w) => path10.join(w.globalRoot, "history"),
-    profileDst: (w, n) => path10.join(w.profilesDir, n, "history")
+    globalSrc: (w) => path11.join(w.globalRoot, "history"),
+    profileDst: (w, n) => path11.join(w.profilesDir, n, "history")
   },
   {
-    globalSrc: (w) => path10.join(w.globalRoot, "sync.json"),
-    profileDst: (w, n) => path10.join(w.profilesDir, n, "sync.json")
+    globalSrc: (w) => path11.join(w.globalRoot, "sync.json"),
+    profileDst: (w, n) => path11.join(w.profilesDir, n, "sync.json")
   },
   {
-    globalSrc: (w) => path10.join(w.globalRoot, "sync-state.json"),
-    profileDst: (w, n) => path10.join(w.profilesDir, n, "sync-state.json")
+    globalSrc: (w) => path11.join(w.globalRoot, "sync-state.json"),
+    profileDst: (w, n) => path11.join(w.profilesDir, n, "sync-state.json")
   },
   {
-    globalSrc: (w) => path10.join(w.globalRoot, "prompt-usage.json"),
-    profileDst: (w, n) => path10.join(w.profilesDir, n, "prompt-usage.json")
+    globalSrc: (w) => path11.join(w.globalRoot, "prompt-usage.json"),
+    profileDst: (w, n) => path11.join(w.profilesDir, n, "prompt-usage.json")
   },
   {
-    globalSrc: (w) => path10.join(w.globalRoot, "custom-context-modes.json"),
-    profileDst: (w, n) => path10.join(w.profilesDir, n, "custom-context-modes.json")
+    globalSrc: (w) => path11.join(w.globalRoot, "custom-context-modes.json"),
+    profileDst: (w, n) => path11.join(w.profilesDir, n, "custom-context-modes.json")
   },
   {
-    globalSrc: (w) => path10.join(w.globalRoot, "desktop.json"),
-    profileDst: (w, n) => path10.join(w.profilesDir, n, "desktop.json")
+    globalSrc: (w) => path11.join(w.globalRoot, "desktop.json"),
+    profileDst: (w, n) => path11.join(w.profilesDir, n, "desktop.json")
   },
   {
-    globalSrc: (w) => path10.join(w.globalRoot, "installed-skills.json"),
-    profileDst: (w, n) => path10.join(w.profilesDir, n, "installed-skills.json")
+    globalSrc: (w) => path11.join(w.globalRoot, "installed-skills.json"),
+    profileDst: (w, n) => path11.join(w.profilesDir, n, "installed-skills.json")
   },
   ...["skills", "prompts", "instructions", "design-kits", "desktop", "settings"].map(
     (directory) => ({
-      globalSrc: (w) => path10.join(w.globalRoot, directory),
-      profileDst: (w, n) => path10.join(w.profilesDir, n, directory)
+      globalSrc: (w) => path11.join(w.globalRoot, directory),
+      profileDst: (w, n) => path11.join(w.profilesDir, n, directory)
     })
   )
 ];
@@ -4868,7 +4918,7 @@ async function migrateProfileFiles(wpaths) {
   } catch {
   }
   try {
-    await fs8.mkdir(path10.join(wpaths.profilesDir, profileName), { recursive: true });
+    await fs8.mkdir(path11.join(wpaths.profilesDir, profileName), { recursive: true });
   } catch {
     return;
   }
@@ -4907,9 +4957,9 @@ async function migrateProfileFiles(wpaths) {
   }
 }
 function assertProjectRootOutsideStateDir(projectRoot, globalRoot) {
-  const stateNamespace = path10.resolve(globalRoot, "projects");
-  const rel = path10.relative(stateNamespace, path10.resolve(projectRoot));
-  if (rel.startsWith("..") || path10.isAbsolute(rel)) return;
+  const stateNamespace = path11.resolve(globalRoot, "projects");
+  const rel = path11.relative(stateNamespace, path11.resolve(projectRoot));
+  if (rel.startsWith("..") || path11.isAbsolute(rel)) return;
   throw new Error(
     `Refusing to start: the resolved project root is inside WrongStack's per-project state directory.
   project root: ${projectRoot}
@@ -4932,7 +4982,7 @@ async function writeProjectMeta(paths, projectRoot, projectId) {
   }
 }
 async function registerProjectInManifest(paths, projectRoot, events, workingDir, projectId) {
-  const manifestPath = path10.join(paths.globalRoot, "projects.json");
+  const manifestPath = path11.join(paths.globalRoot, "projects.json");
   try {
     const t0 = Date.now();
     const raw = await fs8.readFile(manifestPath, "utf8");
@@ -4974,7 +5024,7 @@ async function registerProjectInManifest(paths, projectRoot, events, workingDir,
       if (workingDir) existing.lastWorkingDir = workingDir;
     } else {
       const slug = paths.projectSlug;
-      const name = path10.basename(projectRoot);
+      const name = path11.basename(projectRoot);
       const entry = {
         name,
         root: projectRoot,
@@ -5008,24 +5058,24 @@ async function registerProjectInManifest(paths, projectRoot, events, workingDir,
   }
 }
 async function cleanupStaleProjects(wpaths) {
-  const projectsRoot = path10.dirname(wpaths.projectDir);
+  const projectsRoot = path11.dirname(wpaths.projectDir);
   let entries;
   try {
     entries = await fs8.readdir(projectsRoot, { withFileTypes: true });
   } catch {
     return;
   }
-  const stateNamespace = path10.resolve(projectsRoot);
+  const stateNamespace = path11.resolve(projectsRoot);
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const projectPath = path10.join(projectsRoot, entry.name);
-    const metaPath = path10.join(projectPath, "meta.json");
+    const projectPath = path11.join(projectsRoot, entry.name);
+    const metaPath = path11.join(projectPath, "meta.json");
     try {
       const raw = await fs8.readFile(metaPath, "utf8");
       const meta = JSON.parse(raw);
       if (typeof meta.root !== "string") continue;
-      const rel = path10.relative(stateNamespace, path10.resolve(meta.root));
-      const nested = rel !== "" && !rel.startsWith("..") && !path10.isAbsolute(rel);
+      const rel = path11.relative(stateNamespace, path11.resolve(meta.root));
+      const nested = rel !== "" && !rel.startsWith("..") && !path11.isAbsolute(rel);
       if (nested) {
         await fs8.rm(projectPath, { recursive: true, force: true });
         continue;