replicas-engine 0.1.256 → 0.1.258

package/dist/src/index.js

@@ -3,22 +3,11 @@
 // src/index.ts
 import { serve } from "@hono/node-server";
 import { Hono as Hono2 } from "hono";
-import { readFile as readFile14 } from "fs/promises";
-import { execSync as execSync2 } from "child_process";
 import { randomUUID as randomUUID6 } from "crypto";
 
-// src/managers/github-token-manager.ts
-import { promises as fs } from "fs";
-import path from "path";
-
-// src/engine-env.ts
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-
-// src/runtime-env-loader.ts
-import { readFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
+// src/utils/exec.ts
+import { exec, execFile } from "child_process";
+import { promisify } from "util";
 
 // ../shared/src/type-guards.ts
 function isRecord(value) {
@@ -297,7 +286,7 @@ var WORKSPACE_SIZES = ["small", "large"];
 var INVALID_WORKSPACE_SIZE_ERROR = `Invalid size: must be one of ${WORKSPACE_SIZES.join(", ")}`;
 
 // ../shared/src/e2b.ts
-var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-06-03-v1";
+var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-06-03-v3";
 
 // ../shared/src/runtime-env.ts
 function parsePosixEnvFile(content) {
@@ -358,6 +347,25 @@ function parsePosixEnvFile(content) {
 // ../shared/src/git.ts
 var GIT_PARTIAL_CLONE_FILTER = "blob:none";
 
+// ../shared/src/in-flight.ts
+var InFlightMap = class {
+  pending = /* @__PURE__ */ new Map();
+  run(key, producer) {
+    const existing = this.pending.get(key);
+    if (existing) return existing;
+    const promise = (async () => producer())().finally(() => {
+      if (this.pending.get(key) === promise) {
+        this.pending.delete(key);
+      }
+    });
+    this.pending.set(key, promise);
+    return promise;
+  }
+  get(key) {
+    return this.pending.get(key);
+  }
+};
+
 // ../shared/src/default-skills/replicas-agent/abilities/computer.ts
 var SECTION = `### Computer use (Linux desktop control)
 Drive the workspace's Linux desktop - open a browser, click, type, scroll, screenshot, record - via the \`replicas computer\` CLI. Every Replicas workspace boots with Xvfb / openbox / x11vnc / noVNC pre-installed and the live noVNC viewer is automatically published as an authenticated preview, so a \`Desktop\` tab is always available in the dashboard. Use \`replicas computer info\` to get the viewer URL when you want to share it (e.g. point a user on Slack at the live stream).
@@ -2234,7 +2242,30 @@ var MEDIA_KIND = {
 };
 var MEDIA_KINDS = [MEDIA_KIND.IMAGE, MEDIA_KIND.VIDEO, MEDIA_KIND.AUDIO];
 
+// ../shared/src/github/url.ts
+var GITHUB_HOST_RE = /(^|@|\/\/)github\.com[:/]/;
+function isGitHubUrl(url) {
+  if (!url) return false;
+  return GITHUB_HOST_RE.test(url);
+}
+
+// src/utils/exec.ts
+var execAsync = promisify(exec);
+var execFileAsync = promisify(execFile);
+var SUBPROCESS_MAX_BUFFER = HOOK_EXEC_MAX_BUFFER_BYTES;
+
+// src/managers/github-token-manager.ts
+import { promises as fs } from "fs";
+import path from "path";
+
+// src/engine-env.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+
 // src/runtime-env-loader.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
 function loadRuntimeEnvFile() {
   let content;
   try {
@@ -2730,9 +2761,9 @@ var CodexTokenManager = class extends BaseRefreshManager {
 var codexTokenManager = new CodexTokenManager();
 
 // src/git/service.ts
-import { readdir, stat } from "fs/promises";
-import { existsSync as existsSync2, readFileSync as readFileSync3, unlinkSync } from "fs";
-import { execFileSync as execFileSync2, spawnSync } from "child_process";
+import { readdir, readFile as readFile2, stat } from "fs/promises";
+import { existsSync as existsSync2, unlinkSync } from "fs";
+import { spawn } from "child_process";
 import { join as join5 } from "path";
 
 // src/utils/state.ts
@@ -2863,15 +2894,15 @@ async function saveRepoState(repoName, state, fallbackState) {
 }
 
 // src/git/commands.ts
-import { execFileSync } from "child_process";
 import { readFileSync as readFileSync2 } from "fs";
 import { join as join4 } from "path";
-function runGitCommand(args, cwd) {
-  return execFileSync("git", args, {
+async function runGitCommand(args, cwd, options = {}) {
+  const { stdout } = await execFileAsync("git", args, {
     cwd,
     encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
-  }).trim();
+    maxBuffer: options.maxBuffer ?? SUBPROCESS_MAX_BUFFER
+  });
+  return stdout.trim();
 }
 function readRepoHeadBranch(repoPath) {
   try {
@@ -2882,17 +2913,17 @@ function readRepoHeadBranch(repoPath) {
     return null;
   }
 }
-function branchExists(branchName, cwd) {
+async function branchExists(branchName, cwd) {
   try {
-    runGitCommand(["rev-parse", "--verify", branchName], cwd);
+    await runGitCommand(["rev-parse", "--verify", branchName], cwd);
     return true;
   } catch {
     return false;
   }
 }
-function getCurrentBranch(cwd) {
+async function getCurrentBranch(cwd) {
   try {
-    return runGitCommand(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+    return await runGitCommand(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
   } catch (error) {
     console.error("Error getting current branch:", error);
     return null;
@@ -2900,12 +2931,20 @@ function getCurrentBranch(cwd) {
 }
 
 // src/git/service.ts
+var FULL_DIFF_MAX_BUFFER = 50 * 1024 * 1024;
 function appendUniqueUrl(urls, url) {
   return urls.includes(url) ? urls : [...urls, url];
 }
 var GitService = class {
   defaultBranchCache = /* @__PURE__ */ new Map();
   cachedPrByRepo = /* @__PURE__ */ new Map();
+  // No invalidation on purpose — `git remote set-url` mid-session is rare and
+  // the worst case is `gh pr view` stays skipped until the next engine restart.
+  originIsGitHubCache = /* @__PURE__ */ new Map();
+  // Broadcaster + UI /repos requests fan in here every ~2s; one shared run.
+  listReposInFlight = new InFlightMap();
+  diffStatsInFlight = new InFlightMap();
+  fullDiffInFlight = new InFlightMap();
   getWorkspaceRoot() {
     return ENGINE_ENV.WORKSPACE_ROOT;
   }
@@ -2931,7 +2970,7 @@ var GitService = class {
         repos.push({
           name: entry,
           path: fullPath,
-          defaultBranch: this.resolveDefaultBranch(fullPath)
+          defaultBranch: await this.resolveDefaultBranch(fullPath)
         });
       } catch {
       }
@@ -2940,13 +2979,21 @@ var GitService = class {
   }
   async listRepos(options) {
     const includeDiffs = options?.includeDiffs === true;
+    const key = includeDiffs ? "diffs" : "base";
+    return this.listReposInFlight.run(key, () => this.computeListRepos(includeDiffs));
+  }
+  async computeListRepos(includeDiffs) {
     const repos = await this.listRepositories();
     const states = [];
     for (const repo of repos) {
       try {
-        const persistedState = await loadRepoState(repo.name);
-        const currentBranch = getCurrentBranch(repo.path) ?? repo.defaultBranch;
-        const gitDiff = this.getGitDiffStats(repo.path, repo.defaultBranch);
+        const [persistedState, currentBranchRaw, gitDiff] = await Promise.all([
+          loadRepoState(repo.name),
+          getCurrentBranch(repo.path),
+          this.getGitDiffStats(repo.path, repo.defaultBranch)
+        ]);
+        const currentBranch = currentBranchRaw ?? repo.defaultBranch;
+        const fullDiff = includeDiffs && gitDiff ? await this.getFullGitDiff(repo.path, repo.defaultBranch) : void 0;
         states.push({
           name: repo.name,
           path: repo.path,
@@ -2954,7 +3001,7 @@ var GitService = class {
           currentBranch,
           prUrls: persistedState?.prUrls ?? [],
           // fullDiff may be empty if the diff subprocess fails.
-          gitDiff: includeDiffs && gitDiff ? { ...gitDiff, fullDiff: this.getFullGitDiff(repo.path, repo.defaultBranch) } : gitDiff,
+          gitDiff: includeDiffs && gitDiff ? { ...gitDiff, fullDiff: fullDiff ?? "" } : gitDiff,
           startHooksCompleted: persistedState?.startHooksCompleted ?? false
         });
       } catch {
@@ -2968,7 +3015,7 @@ var GitService = class {
     for (const repo of repos) {
       try {
         const persistedState = await loadRepoState(repo.name);
-        const currentBranch = getCurrentBranch(repo.path) ?? repo.defaultBranch;
+        const currentBranch = await getCurrentBranch(repo.path) ?? repo.defaultBranch;
         const startHooksCompleted = persistedState?.startHooksCompleted ?? false;
         const observed = observedBranchesByRepo?.get(repo.name);
         states.push(
@@ -3033,12 +3080,12 @@ var GitService = class {
         const persistedState = await loadRepoState(repo.name);
         const persistedBranch = persistedState?.currentBranch;
         if (!skipNetworkRefresh) {
-          runGitCommand(["fetch", "--all", "--prune", `--filter=${GIT_PARTIAL_CLONE_FILTER}`], repo.path);
+          await runGitCommand(["fetch", "--all", "--prune", `--filter=${GIT_PARTIAL_CLONE_FILTER}`], repo.path);
         }
-        if (persistedBranch && branchExists(persistedBranch, repo.path)) {
-          const currentBranch = getCurrentBranch(repo.path);
+        if (persistedBranch && await branchExists(persistedBranch, repo.path)) {
+          const currentBranch = await getCurrentBranch(repo.path);
           if (currentBranch !== persistedBranch) {
-            runGitCommand(["checkout", persistedBranch], repo.path);
+            await runGitCommand(["checkout", persistedBranch], repo.path);
           }
           results.push({
             name: repo.name,
@@ -3048,15 +3095,15 @@ var GitService = class {
           });
           continue;
         }
-        runGitCommand(["checkout", repo.defaultBranch], repo.path);
+        await runGitCommand(["checkout", repo.defaultBranch], repo.path);
         if (!skipNetworkRefresh) {
           try {
-            runGitCommand(["pull", "--rebase", "--autostash"], repo.path);
+            await runGitCommand(["pull", "--rebase", "--autostash"], repo.path);
           } catch {
           }
         }
-        const branchName = this.findAvailableBranchName(workspaceName, repo.path);
-        runGitCommand(["checkout", "-b", branchName], repo.path);
+        const branchName = await this.findAvailableBranchName(workspaceName, repo.path);
+        await runGitCommand(["checkout", "-b", branchName], repo.path);
         await saveRepoState(repo.name, { currentBranch: branchName }, baselineState);
         results.push({
           name: repo.name,
@@ -3094,109 +3141,149 @@ var GitService = class {
     return true;
   }
   getGitDiffStats(repoPath, defaultBranch) {
-    try {
-      const diffBase = this.getDiffBase(repoPath, defaultBranch);
-      const shortstat = runGitCommand(["diff", diffBase, "--shortstat", "-M"], repoPath);
-      let added = 0;
-      let removed = 0;
-      const addedMatch = shortstat.match(/(\d+) insertion/);
-      const removedMatch = shortstat.match(/(\d+) deletion/);
-      if (addedMatch) {
-        added = parseInt(addedMatch[1], 10);
-      }
-      if (removedMatch) {
-        removed = parseInt(removedMatch[1], 10);
-      }
-      added += this.countUntrackedAddedLines(repoPath);
-      return {
-        added,
-        removed
-      };
-    } catch (error) {
-      console.error("Error getting git diff:", error);
-      return null;
-    }
+    return this.diffStatsInFlight.run(repoPath, async () => {
+      try {
+        const diffBase = await this.getDiffBase(repoPath, defaultBranch);
+        const shortstat = await runGitCommand(["diff", diffBase, "--shortstat", "-M"], repoPath);
+        let added = 0;
+        let removed = 0;
+        const addedMatch = shortstat.match(/(\d+) insertion/);
+        const removedMatch = shortstat.match(/(\d+) deletion/);
+        if (addedMatch) {
+          added = parseInt(addedMatch[1], 10);
+        }
+        if (removedMatch) {
+          removed = parseInt(removedMatch[1], 10);
+        }
+        added += await this.countUntrackedAddedLines(repoPath);
+        return {
+          added,
+          removed
+        };
+      } catch (error) {
+        console.error("Error getting git diff:", error);
+        return null;
+      }
+    });
   }
-  listUntrackedPaths(repoPath) {
-    const listing = execFileSync2("git", ["ls-files", "--others", "--exclude-standard", "-z"], {
+  async listUntrackedPaths(repoPath) {
+    const { stdout } = await execFileAsync("git", ["ls-files", "--others", "--exclude-standard", "-z"], {
       cwd: repoPath,
       encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
+      maxBuffer: SUBPROCESS_MAX_BUFFER
     });
-    return listing.split("\0").filter(Boolean);
+    return stdout.split("\0").filter(Boolean);
   }
-  getUntrackedDiff(repoPath) {
-    const paths = this.listUntrackedPaths(repoPath);
+  async getUntrackedDiff(repoPath) {
+    const paths = await this.listUntrackedPaths(repoPath);
     if (paths.length === 0) return "";
     try {
-      execFileSync2("git", ["add", "--intent-to-add", "--", ...paths], { cwd: repoPath, stdio: ["pipe", "pipe", "pipe"] });
-      const result = spawnSync("git", ["diff", "--", ...paths], {
+      await execFileAsync("git", ["add", "--intent-to-add", "--", ...paths], {
         cwd: repoPath,
-        encoding: "utf-8",
-        maxBuffer: 50 * 1024 * 1024
+        maxBuffer: SUBPROCESS_MAX_BUFFER
       });
-      return result.status === 0 || result.status === 1 ? result.stdout : "";
+      return await this.readUntrackedDiff(repoPath, paths);
     } finally {
       try {
-        execFileSync2("git", ["reset", "--", ...paths], { cwd: repoPath, stdio: ["pipe", "pipe", "pipe"] });
+        await execFileAsync("git", ["reset", "--", ...paths], {
+          cwd: repoPath,
+          maxBuffer: SUBPROCESS_MAX_BUFFER
+        });
       } catch {
       }
     }
   }
-  countUntrackedAddedLines(repoPath) {
+  readUntrackedDiff(repoPath, paths) {
+    return new Promise((resolve3) => {
+      const child = spawn("git", ["diff", "--", ...paths], {
+        cwd: repoPath,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const chunks = [];
+      let total = 0;
+      let truncated = false;
+      child.stdout.on("data", (chunk) => {
+        if (truncated) return;
+        total += chunk.length;
+        if (total > FULL_DIFF_MAX_BUFFER) {
+          truncated = true;
+          chunks.push(chunk.subarray(0, Math.max(0, FULL_DIFF_MAX_BUFFER - (total - chunk.length))));
+          child.kill("SIGTERM");
+          return;
+        }
+        chunks.push(chunk);
+      });
+      child.stderr.on("data", () => {
+      });
+      child.on("error", () => resolve3(""));
+      child.on("close", (code) => {
+        if (code === 0 || code === 1 || truncated) {
+          resolve3(Buffer.concat(chunks).toString("utf-8"));
+        } else {
+          resolve3("");
+        }
+      });
+    });
+  }
+  async countUntrackedAddedLines(repoPath) {
     try {
-      return this.listUntrackedPaths(repoPath).reduce((total, path4) => {
+      const paths = await this.listUntrackedPaths(repoPath);
+      let total = 0;
+      for (const path4 of paths) {
         try {
-          const contents = readFileSync3(join5(repoPath, path4));
+          const contents = await readFile2(join5(repoPath, path4));
           if (contents.length === 0 || contents.includes(0)) {
-            return total;
+            continue;
           }
           let lines = 0;
           for (const byte of contents) {
             if (byte === 10) lines += 1;
           }
-          return total + lines + (contents[contents.length - 1] === 10 ? 0 : 1);
+          total += lines + (contents[contents.length - 1] === 10 ? 0 : 1);
         } catch {
-          return total;
         }
-      }, 0);
+      }
+      return total;
     } catch (error) {
       console.error("Error counting untracked added lines:", error);
       return 0;
     }
   }
   getFullGitDiff(repoPath, defaultBranch) {
-    try {
-      const diffBase = this.getDiffBase(repoPath, defaultBranch);
-      const trackedDiff = execFileSync2("git", ["diff", diffBase, "-M", "-C"], {
-        cwd: repoPath,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      return trackedDiff + this.getUntrackedAsDiff(repoPath);
-    } catch {
-      return "";
-    }
+    return this.fullDiffInFlight.run(repoPath, async () => {
+      try {
+        const diffBase = await this.getDiffBase(repoPath, defaultBranch);
+        const { stdout: trackedDiff } = await execFileAsync("git", ["diff", diffBase, "-M", "-C"], {
+          cwd: repoPath,
+          encoding: "utf-8",
+          maxBuffer: FULL_DIFF_MAX_BUFFER
+        });
+        const untrackedDiff = await this.getUntrackedAsDiff(repoPath);
+        return trackedDiff + untrackedDiff;
+      } catch {
+        return "";
+      }
+    });
   }
-  getUntrackedAsDiff(repoPath) {
+  async getUntrackedAsDiff(repoPath) {
     try {
-      return this.getUntrackedDiff(repoPath);
+      return await this.getUntrackedDiff(repoPath);
     } catch (error) {
       console.error("Error building untracked diff:", error);
       return "";
     }
   }
-  getDiffBase(repoPath, defaultBranch) {
+  async getDiffBase(repoPath, defaultBranch) {
     const baseBranch = `origin/${defaultBranch}`;
     try {
-      return runGitCommand(["merge-base", baseBranch, "HEAD"], repoPath);
+      return await runGitCommand(["merge-base", baseBranch, "HEAD"], repoPath);
     } catch {
       return baseBranch;
     }
   }
   async getPullRequestUrl(repoName, repoPath, currentBranchArg, persistedRepoStateArg) {
     try {
-      const currentBranch = currentBranchArg ?? getCurrentBranch(repoPath);
+      const currentBranch = currentBranchArg ?? await getCurrentBranch(repoPath);
       if (!currentBranch) {
         return { status: "not_found" };
       }
@@ -3206,7 +3293,7 @@ var GitService = class {
       }
       const persistedRepoState = persistedRepoStateArg ?? await loadRepoState(repoName);
       this.cachedPrByRepo.delete(repoName);
-      const result = this.lookupPrOnRemote(repoName, repoPath, currentBranch);
+      const result = await this.lookupPrOnRemote(repoName, repoPath, currentBranch);
       if (result.status === "found") {
         this.cachedPrByRepo.set(repoName, { prUrl: result.url, currentBranch });
         if (persistedRepoState && !persistedRepoState.prUrls.includes(result.url)) {
@@ -3223,25 +3310,29 @@ var GitService = class {
       return { status: "error" };
     }
   }
-  lookupPrOnRemote(repoName, repoPath, branch) {
+  async lookupPrOnRemote(repoName, repoPath, branch) {
+    if (!await this.originIsGitHub(repoPath)) {
+      return { status: "not_found" };
+    }
     try {
-      const remoteRef = execFileSync2("git", ["ls-remote", "--heads", "origin", branch], {
+      const { stdout } = await execFileAsync("git", ["ls-remote", "--heads", "origin", branch], {
         cwd: repoPath,
         encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
-      if (!remoteRef) {
+        maxBuffer: SUBPROCESS_MAX_BUFFER
+      });
+      if (!stdout.trim()) {
         return { status: "not_found" };
       }
     } catch {
       return { status: "error" };
     }
     try {
-      const prInfo = execFileSync2("gh", ["pr", "view", branch, "--json", "url", "--jq", ".url"], {
+      const { stdout } = await execFileAsync("gh", ["pr", "view", branch, "--json", "url", "--jq", ".url"], {
         cwd: repoPath,
         encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
+        maxBuffer: SUBPROCESS_MAX_BUFFER
+      });
+      const prInfo = stdout.trim();
       return prInfo ? { status: "found", url: prInfo } : { status: "not_found" };
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -3249,12 +3340,31 @@ var GitService = class {
       return { status: "error" };
     }
   }
-  resolveDefaultBranch(repoPath) {
+  async originIsGitHub(repoPath) {
+    const cached = this.originIsGitHubCache.get(repoPath);
+    if (cached !== void 0) {
+      return cached;
+    }
+    let isGitHub = false;
+    try {
+      const { stdout } = await execFileAsync("git", ["remote", "get-url", "origin"], {
+        cwd: repoPath,
+        encoding: "utf-8",
+        maxBuffer: SUBPROCESS_MAX_BUFFER
+      });
+      isGitHub = isGitHubUrl(stdout.trim());
+    } catch {
+      isGitHub = false;
+    }
+    this.originIsGitHubCache.set(repoPath, isGitHub);
+    return isGitHub;
+  }
+  async resolveDefaultBranch(repoPath) {
     const cached = this.defaultBranchCache.get(repoPath);
     if (cached) {
       return cached;
     }
-    const fromSymbolicRef = this.resolveDefaultBranchFromSymbolicRef(repoPath);
+    const fromSymbolicRef = await this.resolveDefaultBranchFromSymbolicRef(repoPath);
     if (fromSymbolicRef) {
       this.defaultBranchCache.set(repoPath, fromSymbolicRef);
       return fromSymbolicRef;
@@ -3263,18 +3373,18 @@ var GitService = class {
     this.defaultBranchCache.set(repoPath, fallback);
     return fallback;
   }
-  resolveDefaultBranchFromSymbolicRef(repoPath) {
+  async resolveDefaultBranchFromSymbolicRef(repoPath) {
     try {
-      const output = runGitCommand(["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], repoPath);
+      const output = await runGitCommand(["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], repoPath);
       const match = output.match(/^origin\/(.+)$/);
       return match ? match[1] : null;
     } catch {
       return null;
     }
   }
-  findAvailableBranchName(baseName, cwd) {
+  async findAvailableBranchName(baseName, cwd) {
     const sanitizedBaseName = this.sanitizeBranchName(baseName);
-    if (!branchExists(sanitizedBaseName, cwd)) {
+    if (!await branchExists(sanitizedBaseName, cwd)) {
       return sanitizedBaseName;
     }
     return `${sanitizedBaseName}-${Date.now()}`;
@@ -3292,7 +3402,7 @@ var GitService = class {
     if (observedBranches) {
       for (const branch of observedBranches) {
         if (branch === currentBranch) continue;
-        const branchResult = this.lookupPrOnRemote(repo.name, repo.path, branch);
+        const branchResult = await this.lookupPrOnRemote(repo.name, repo.path, branch);
         if (branchResult.status === "found") {
           prUrls = appendUniqueUrl(prUrls, branchResult.url);
         }
@@ -3304,7 +3414,7 @@ var GitService = class {
       defaultBranch: repo.defaultBranch,
       currentBranch,
       prUrls,
-      gitDiff: this.getGitDiffStats(repo.path, repo.defaultBranch),
+      gitDiff: await this.getGitDiffStats(repo.path, repo.defaultBranch),
       startHooksCompleted
     };
     await saveRepoState(repo.name, state, state);
@@ -3392,20 +3502,17 @@ var EngineLogger = class {
 var engineLogger = new EngineLogger();
 
 // src/services/replicas-config-service.ts
-import { readFile as readFile4, appendFile as appendFile2, writeFile as writeFile4, mkdir as mkdir5 } from "fs/promises";
+import { readFile as readFile5, appendFile as appendFile2, writeFile as writeFile4, mkdir as mkdir5 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
 import { join as join9 } from "path";
 import { homedir as homedir7 } from "os";
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 
 // src/services/environment-details-service.ts
-import { mkdir as mkdir3, readFile as readFile2 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile3 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
 import { homedir as homedir5 } from "os";
 import { join as join7 } from "path";
-import { execFile } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
 var REPLICAS_DIR = join7(homedir5(), ".replicas");
 var DETAILS_FILE = join7(REPLICAS_DIR, "environment-details.json");
 var CLAUDE_CREDENTIALS_PATH = join7(homedir5(), ".claude", ".credentials.json");
@@ -3478,7 +3585,7 @@ async function readDetails() {
     if (!existsSync3(DETAILS_FILE)) {
       return createDefaultDetails();
     }
-    const raw = await readFile2(DETAILS_FILE, "utf-8");
+    const raw = await readFile3(DETAILS_FILE, "utf-8");
     const parsed = JSON.parse(raw);
     return { ...createDefaultDetails(), ...parsed };
   } catch {
@@ -3572,7 +3679,7 @@ var EnvironmentDetailsService = class {
 var environmentDetailsService = new EnvironmentDetailsService();
 
 // src/services/start-hook-logs-service.ts
-import { mkdir as mkdir4, readFile as readFile3, writeFile as writeFile3, readdir as readdir2 } from "fs/promises";
+import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile3, readdir as readdir2 } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import { join as join8 } from "path";
 
@@ -3649,7 +3756,7 @@ var StartHookLogsService = class {
         continue;
       }
       try {
-        const raw = await readFile3(join8(LOGS_DIR, file), "utf-8");
+        const raw = await readFile4(join8(LOGS_DIR, file), "utf-8");
         const stored = normalizeStored(JSON.parse(raw));
         if (stored) {
           logs.push(withPreview(stored));
@@ -3668,7 +3775,7 @@ var StartHookLogsService = class {
   async getFullOutput(hookType, hookName) {
     const filename = hookType === "environment" ? ENVIRONMENT_HOOK_LOG_FILENAME : repoHookLogFilename(hookName);
     try {
-      const raw = await readFile3(join8(LOGS_DIR, filename), "utf-8");
+      const raw = await readFile4(join8(LOGS_DIR, filename), "utf-8");
       const stored = normalizeStored(JSON.parse(raw));
       if (!stored || stored.hookType !== hookType || stored.hookName !== hookName) {
         return null;
@@ -3700,7 +3807,7 @@ async function readReplicasConfigFromDir(dirPath) {
     if (!existsSync4(configPath)) {
       continue;
     }
-    const data = await readFile4(configPath, "utf-8");
+    const data = await readFile5(configPath, "utf-8");
     const config = parseReplicasConfigString(data, filename);
     return { config, filename };
   }
@@ -3802,7 +3909,7 @@ var ReplicasConfigService = class {
     emit(`$ ${params.label}
 `);
     return new Promise((resolve3) => {
-      const proc = spawn("bash", ["-lc", params.command], {
+      const proc = spawn2("bash", ["-lc", params.command], {
         cwd: params.cwd,
         env: process.env,
         stdio: ["pipe", "pipe", "pipe"]
@@ -4135,7 +4242,7 @@ var EventService = class {
 var eventService = new EventService();
 
 // src/services/preview-service.ts
-import { mkdir as mkdir7, readFile as readFile5 } from "fs/promises";
+import { mkdir as mkdir7, readFile as readFile6 } from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
 import { homedir as homedir9 } from "os";
@@ -4146,7 +4253,7 @@ async function readPreviewsFile() {
     if (!existsSync5(PREVIEW_PORTS_FILE)) {
       return { previews: [] };
     }
-    const raw = await readFile5(PREVIEW_PORTS_FILE, "utf-8");
+    const raw = await readFile6(PREVIEW_PORTS_FILE, "utf-8");
     return JSON.parse(raw);
   } catch {
     return { previews: [] };
@@ -4251,7 +4358,7 @@ async function registerDesktopPreview() {
 
 // src/services/chat/chat-service.ts
 import { existsSync as existsSync8 } from "fs";
-import { appendFile as appendFile5, copyFile, mkdir as mkdir11, readFile as readFile8, rename as rename2, rm } from "fs/promises";
+import { appendFile as appendFile5, copyFile, mkdir as mkdir11, readFile as readFile9, rename as rename2, rm } from "fs/promises";
 import { homedir as homedir13 } from "os";
 import { join as join15 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
@@ -4266,7 +4373,7 @@ import { mkdir as mkdir9, appendFile as appendFile4 } from "fs/promises";
 import { homedir as homedir11 } from "os";
 
 // src/utils/jsonl-reader.ts
-import { readFile as readFile6 } from "fs/promises";
+import { readFile as readFile7 } from "fs/promises";
 function isJsonlEvent(value) {
   if (!isRecord4(value)) {
     return false;
@@ -4288,7 +4395,7 @@ function parseJsonlEvents(lines) {
 }
 async function readJSONL(filePath) {
   try {
-    const content = await readFile6(filePath, "utf-8");
+    const content = await readFile7(filePath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim());
     return parseJsonlEvents(lines);
   } catch (error) {
@@ -6039,7 +6146,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
 };
 
 // src/managers/codex-asp/app-server-process.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { EventEmitter as EventEmitter2 } from "events";
 
 // src/managers/codex-asp/asp-client.ts
@@ -6234,7 +6341,7 @@ var AspClient = class {
 // src/managers/codex-asp/app-server-process.ts
 var DEFAULT_CODEX_BINARY = "codex";
 var DEFAULT_CODEX_ARGS = ["app-server", "--listen", "stdio://"];
-var ENGINE_PACKAGE_VERSION = "0.1.256";
+var ENGINE_PACKAGE_VERSION = "0.1.258";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -6261,7 +6368,7 @@ var AppServerProcess = class {
       return { client: this.client };
     }
     this.shuttingDown = false;
-    const child = spawn2(this.binary, this.args, {
+    const child = spawn3(this.binary, this.args, {
       cwd: this.cwd,
       env: this.env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -6501,7 +6608,7 @@ function isCodexAuthError(error) {
 }
 
 // src/managers/codex-asp/mappers.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
 var localImageCache = /* @__PURE__ */ new Map();
 var DEFAULT_MODEL = DEFAULT_CODEX_MODEL;
 var THREAD_START_METHOD = "thread/start";
@@ -6582,7 +6689,7 @@ function userImageForLocalPath(path4) {
   const image = {
     type: "image",
     mediaType: inferMediaType(path4),
-    data: readFileSync4(path4).toString("base64")
+    data: readFileSync3(path4).toString("base64")
   };
   if (image.data.length > 0) localImageCache.set(path4, image);
   return image;
@@ -7854,7 +7961,7 @@ var CodexAspManager = class extends CodingAgentManager {
 
 // src/managers/codex-manager.ts
 import { Codex } from "@openai/codex-sdk";
-import { readdir as readdir3, stat as stat2, writeFile as writeFile6, mkdir as mkdir10, readFile as readFile7 } from "fs/promises";
+import { readdir as readdir3, stat as stat2, writeFile as writeFile6, mkdir as mkdir10, readFile as readFile8 } from "fs/promises";
 import { existsSync as existsSync7 } from "fs";
 import { join as join14 } from "path";
 import { homedir as homedir12 } from "os";
@@ -7902,7 +8009,7 @@ var CodexManager = class extends CodingAgentManager {
     try {
       const sessionFile = await this.findSessionFile(this.currentThreadId);
       if (!sessionFile) return;
-      const content = await readFile7(sessionFile, "utf-8");
+      const content = await readFile8(sessionFile, "utf-8");
       const lines = content.split("\n").map((line) => line.trim()).filter(Boolean);
       let latest = null;
       for (const line of lines) {
@@ -7942,7 +8049,7 @@ var CodexManager = class extends CodingAgentManager {
       let config = {};
       if (existsSync7(CODEX_CONFIG_PATH)) {
         try {
-          const existingContent = await readFile7(CODEX_CONFIG_PATH, "utf-8");
+          const existingContent = await readFile8(CODEX_CONFIG_PATH, "utf-8");
           const parsed = parseToml(existingContent);
           if (isRecord4(parsed)) {
             config = parsed;
@@ -8185,7 +8292,7 @@ var CodexManager = class extends CodingAgentManager {
     const seenLines = /* @__PURE__ */ new Set();
     const seedSeenLines = async () => {
       try {
-        const content = await readFile7(sessionFile, "utf-8");
+        const content = await readFile8(sessionFile, "utf-8");
         const lines = content.split("\n").map((line) => line.trim()).filter(Boolean);
         let latest = null;
         for (const line of lines) {
@@ -8207,7 +8314,7 @@ var CodexManager = class extends CodingAgentManager {
     const pump = async () => {
       let emitted = 0;
       try {
-        const content = await readFile7(sessionFile, "utf-8");
+        const content = await readFile8(sessionFile, "utf-8");
         const lines = content.split("\n");
         const completeLines = content.endsWith("\n") ? lines : lines.slice(0, -1);
         for (const line of completeLines) {
@@ -9070,7 +9177,7 @@ var ChatService = class {
   }
   async readSenders(chatId) {
     try {
-      const content = await readFile8(this.senderFilePath(chatId), "utf-8");
+      const content = await readFile9(this.senderFilePath(chatId), "utf-8");
       const lines = content.split("\n").filter((line) => line.trim().length > 0);
       const senders = [];
       for (const line of lines) {
@@ -9427,7 +9534,7 @@ var ChatService = class {
   }
   async loadChats() {
     try {
-      const content = await readFile8(CHATS_FILE, "utf-8");
+      const content = await readFile9(CHATS_FILE, "utf-8");
       return parsePersistedChatsContent(content);
     } catch (error) {
       if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
@@ -9442,7 +9549,7 @@ var ChatService = class {
         console.error("[ChatService] Failed to quarantine corrupt chats file:", renameError);
       }
       try {
-        const backupContent = await readFile8(CHATS_BACKUP_FILE, "utf-8");
+        const backupContent = await readFile9(CHATS_BACKUP_FILE, "utf-8");
         return parsePersistedChatsContent(backupContent);
       } catch (backupError) {
         if (backupError && typeof backupError === "object" && "code" in backupError && backupError.code === "ENOENT") {
@@ -9517,7 +9624,7 @@ var ChatService = class {
 
 // src/services/repo-file-service.ts
 import { execFile as execFile2 } from "child_process";
-import { readFile as readFile9, realpath, stat as stat3 } from "fs/promises";
+import { readFile as readFile10, realpath, stat as stat3 } from "fs/promises";
 import { join as join16, resolve, extname } from "path";
 var CACHE_TTL_MS = 3e4;
 var SEARCH_TIMEOUT_MS = 15e3;
@@ -9707,7 +9814,7 @@ var RepoFileService = class {
           tooLarge: true
         };
       }
-      const content = await readFile9(fullPath, "utf-8");
+      const content = await readFile10(fullPath, "utf-8");
       return {
         repoName,
         path: filePath,
@@ -9789,11 +9896,11 @@ var RepoFileService = class {
 // src/v1-routes.ts
 import { Hono } from "hono";
 import { z as z2 } from "zod";
-import { readdir as readdir6, stat as stat4, readFile as readFile13 } from "fs/promises";
+import { readdir as readdir6, stat as stat4, readFile as readFile14 } from "fs/promises";
 import { join as join20, resolve as resolve2 } from "path";
 
 // src/services/plan-service.ts
-import { readdir as readdir4, readFile as readFile10 } from "fs/promises";
+import { readdir as readdir4, readFile as readFile11 } from "fs/promises";
 import { homedir as homedir14 } from "os";
 import { basename, join as join17 } from "path";
 var PLAN_DIRECTORIES = [
@@ -9834,7 +9941,7 @@ var PlanService = class {
     for (const directory of PLAN_DIRECTORIES) {
       const filePath = join17(directory, safeFilename);
       try {
-        const content = await readFile10(filePath, "utf-8");
+        const content = await readFile11(filePath, "utf-8");
         return { filename: safeFilename, content };
       } catch {
       }
@@ -9845,13 +9952,13 @@ var PlanService = class {
 var planService = new PlanService();
 
 // src/services/warm-hooks-service.ts
-import { spawn as spawn3 } from "child_process";
-import { readFile as readFile12 } from "fs/promises";
+import { spawn as spawn4 } from "child_process";
+import { readFile as readFile13 } from "fs/promises";
 import { existsSync as existsSync9 } from "fs";
 import { join as join19 } from "path";
 
 // src/services/warm-hook-logs-service.ts
-import { mkdir as mkdir12, readFile as readFile11, writeFile as writeFile7, readdir as readdir5, appendFile as appendFile6, unlink as unlink3 } from "fs/promises";
+import { mkdir as mkdir12, readFile as readFile12, writeFile as writeFile7, readdir as readdir5, appendFile as appendFile6, unlink as unlink3 } from "fs/promises";
 import { homedir as homedir15 } from "os";
 import { join as join18 } from "path";
 var LOGS_DIR2 = join18(homedir15(), ".replicas", "warm-hook-logs");
@@ -9911,7 +10018,7 @@ var WarmHookLogsService = class {
         continue;
       }
       try {
-        const raw = await readFile11(join18(LOGS_DIR2, file), "utf-8");
+        const raw = await readFile12(join18(LOGS_DIR2, file), "utf-8");
         const stored = JSON.parse(raw);
         logs.push(withPreview2(stored));
       } catch {
@@ -9940,7 +10047,7 @@ var WarmHookLogsService = class {
   }
   async getCurrentRunLog() {
     try {
-      return await readFile11(CURRENT_RUN_LOG, "utf-8");
+      return await readFile12(CURRENT_RUN_LOG, "utf-8");
     } catch (err) {
       if (err.code === "ENOENT") return null;
       throw err;
@@ -9949,7 +10056,7 @@ var WarmHookLogsService = class {
   async getFullOutput(hookType, hookName) {
     const filename = hookType === "global" ? GLOBAL_FILENAME : hookType === "environment" ? ENVIRONMENT_HOOK_LOG_FILENAME : repoHookLogFilename(hookName);
     try {
-      const raw = await readFile11(join18(LOGS_DIR2, filename), "utf-8");
+      const raw = await readFile12(join18(LOGS_DIR2, filename), "utf-8");
       const stored = JSON.parse(raw);
       if (stored.hookType !== hookType || stored.hookName !== hookName) {
         return null;
@@ -9973,7 +10080,7 @@ async function readRepoWarmHook(repoPath) {
       continue;
     }
     try {
-      const raw = await readFile12(configPath, "utf-8");
+      const raw = await readFile13(configPath, "utf-8");
       const config = parseReplicasConfigString(raw, filename);
       if (!config.warmHook) {
         return null;
@@ -10020,7 +10127,7 @@ async function executeHookScriptStreaming(params) {
   params.onChunk(`$ ${params.label}
 `);
   return new Promise((resolve3) => {
-    const proc = spawn3("bash", ["-lc", params.content], {
+    const proc = spawn4("bash", ["-lc", params.content], {
       cwd: params.cwd,
       env: process.env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -10903,7 +11010,7 @@ function createV1Routes(deps) {
       const limit = Math.min(parseInt(c.req.query("limit") || "500", 10), 5e3);
       let content;
       try {
-        content = await readFile13(filePath, "utf-8");
+        content = await readFile14(filePath, "utf-8");
       } catch {
         return c.json(jsonError("Log session not found"), 404);
       }
@@ -10943,12 +11050,10 @@ process.on("unhandledRejection", (reason) => {
   engineLogger.flush().finally(() => process.exit(1));
 });
 await eventService.initialize();
-var READY_MESSAGE = "========= REPLICAS WORKSPACE READY ==========";
-var COMPLETION_MESSAGE = "========= REPLICAS WORKSPACE INITIALIZATION COMPLETE ==========";
-function checkActiveSSHSessions() {
+async function checkActiveSSHSessions() {
   try {
-    const output = execSync2('who | grep -v "^$" | wc -l', { encoding: "utf-8" });
-    const sessionCount = parseInt(output.trim(), 10);
+    const { stdout } = await execAsync('who | grep -v "^$" | wc -l', { encoding: "utf-8" });
+    const sessionCount = parseInt(stdout.trim(), 10);
     return sessionCount > 0;
   } catch {
     return false;
@@ -10972,32 +11077,22 @@ var authMiddleware = async (c, next) => {
   await next();
 };
 var chatService = new ChatService(gitService.getWorkspaceRoot());
-app.get("/health", async (c) => {
+app.get("/health", (c) => {
   if (!engineReady) {
     return c.json({ status: "initializing", timestamp: (/* @__PURE__ */ new Date()).toISOString() }, 503);
   }
-  try {
-    const logContent = await readFile14("/var/log/cloud-init-output.log", "utf-8");
-    let status;
-    if (logContent.includes(COMPLETION_MESSAGE)) {
-      status = "active";
-    } else if (logContent.includes(READY_MESSAGE)) {
-      status = "ready";
-    } else {
-      status = "initializing";
-    }
-    return c.json({ status, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-  } catch {
-    return c.json({ status: "initializing", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-  }
+  return c.json({ status: "active", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
 });
 app.use("*", authMiddleware);
 app.get("/status", async (c) => {
   try {
-    const repos = await gitService.listRepos();
+    const [repos, hasActiveSSHSessions] = await Promise.all([
+      gitService.listRepos(),
+      checkActiveSSHSessions()
+    ]);
     const status = {
       uptimeSeconds: Math.floor((Date.now() - bootTimeMs) / 1e3),
-      hasActiveSSHSessions: checkActiveSSHSessions(),
+      hasActiveSSHSessions,
       activeSseClients: eventService.getSubscriberCount(),
       chatsTotal: chatService.listChats().length,
       chatsProcessing: chatService.getProcessingCount(),
@@ -11027,8 +11122,16 @@ function startStatusBroadcaster() {
   let previousHookStatus = "";
   let previousEngineStatus = "";
   let lastHooksRunning = replicasConfigService.areHooksRunning();
-  setInterval(() => {
-    gitService.listRepos().then((repos) => {
+  const BROADCAST_INTERVAL_MS = 2e3;
+  const scheduleNext = () => {
+    setTimeout(tick, BROADCAST_INTERVAL_MS);
+  };
+  const tick = async () => {
+    try {
+      const [repos, hasActiveSSHSessions] = await Promise.all([
+        gitService.listRepos(),
+        checkActiveSSHSessions()
+      ]);
       const serialized = JSON.stringify(repos);
       if (serialized !== previousRepoStatus) {
         previousRepoStatus = serialized;
@@ -11042,7 +11145,7 @@ function startStatusBroadcaster() {
       }
       const engineStatus = {
         uptimeSeconds: Math.floor((Date.now() - bootTimeMs) / 1e3),
-        hasActiveSSHSessions: checkActiveSSHSessions(),
+        hasActiveSSHSessions,
         activeSseClients: eventService.getSubscriberCount(),
         chatsTotal: chatService.listChats().length,
         chatsProcessing: chatService.getProcessingCount(),
@@ -11060,67 +11163,70 @@ function startStatusBroadcaster() {
         }).catch(() => {
         });
       }
-    }).catch(() => {
-    });
-    const hooksRunning = replicasConfigService.areHooksRunning();
-    const hooksCompleted = replicasConfigService.areHooksCompleted();
-    const hooksFailed = replicasConfigService.didHooksFail();
-    const hookSnapshot = JSON.stringify({
-      running: hooksRunning,
-      completed: hooksCompleted,
-      failed: hooksFailed
-    });
-    if (hookSnapshot !== previousHookStatus) {
-      previousHookStatus = hookSnapshot;
-      if (!lastHooksRunning && hooksRunning) {
-        eventService.publish({
-          id: randomUUID6(),
-          ts: (/* @__PURE__ */ new Date()).toISOString(),
-          type: "hooks.started",
-          payload: { running: true, completed: false }
-        }).catch(() => {
-        });
-      }
-      if (hooksRunning) {
-        eventService.publish({
-          id: randomUUID6(),
-          ts: (/* @__PURE__ */ new Date()).toISOString(),
-          type: "hooks.progress",
-          payload: { running: true, completed: false }
-        }).catch(() => {
-        });
-      }
-      if (lastHooksRunning && !hooksRunning && hooksCompleted && !hooksFailed) {
-        eventService.publish({
-          id: randomUUID6(),
-          ts: (/* @__PURE__ */ new Date()).toISOString(),
-          type: "hooks.completed",
-          payload: { running: false, completed: true }
-        }).catch(() => {
-        });
-      }
-      if (lastHooksRunning && !hooksRunning && hooksFailed) {
+      const hooksRunning = replicasConfigService.areHooksRunning();
+      const hooksCompleted = replicasConfigService.areHooksCompleted();
+      const hooksFailed = replicasConfigService.didHooksFail();
+      const hookSnapshot = JSON.stringify({
+        running: hooksRunning,
+        completed: hooksCompleted,
+        failed: hooksFailed
+      });
+      if (hookSnapshot !== previousHookStatus) {
+        previousHookStatus = hookSnapshot;
+        if (!lastHooksRunning && hooksRunning) {
+          eventService.publish({
+            id: randomUUID6(),
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            type: "hooks.started",
+            payload: { running: true, completed: false }
+          }).catch(() => {
+          });
+        }
+        if (hooksRunning) {
+          eventService.publish({
+            id: randomUUID6(),
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            type: "hooks.progress",
+            payload: { running: true, completed: false }
+          }).catch(() => {
+          });
+        }
+        if (lastHooksRunning && !hooksRunning && hooksCompleted && !hooksFailed) {
+          eventService.publish({
+            id: randomUUID6(),
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            type: "hooks.completed",
+            payload: { running: false, completed: true }
+          }).catch(() => {
+          });
+        }
+        if (lastHooksRunning && !hooksRunning && hooksFailed) {
+          eventService.publish({
+            id: randomUUID6(),
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            type: "hooks.failed",
+            payload: { running: false, completed: hooksCompleted }
+          }).catch(() => {
+          });
+        }
         eventService.publish({
           id: randomUUID6(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
-          type: "hooks.failed",
-          payload: { running: false, completed: hooksCompleted }
+          type: "hooks.status",
+          payload: {
+            running: hooksRunning,
+            completed: hooksCompleted
+          }
         }).catch(() => {
         });
+        lastHooksRunning = hooksRunning;
       }
-      eventService.publish({
-        id: randomUUID6(),
-        ts: (/* @__PURE__ */ new Date()).toISOString(),
-        type: "hooks.status",
-        payload: {
-          running: hooksRunning,
-          completed: hooksCompleted
-        }
-      }).catch(() => {
-      });
-      lastHooksRunning = hooksRunning;
+    } catch {
+    } finally {
+      scheduleNext();
     }
-  }, 2e3);
+  };
+  scheduleNext();
 }
 serve(
   {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.256",
+  "version": "0.1.258",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",