replicas-engine 0.1.41 → 0.1.43

package/dist/src/index.js

@@ -5,14 +5,76 @@ import "./chunk-ZXMDA7VB.js";
 import "dotenv/config";
 import { serve } from "@hono/node-server";
 import { Hono as Hono2 } from "hono";
-import { readFile as readFile8 } from "fs/promises";
-import { execSync as execSync2 } from "child_process";
-import { randomUUID as randomUUID5 } from "crypto";
+import { readFile as readFile7 } from "fs/promises";
+import { execSync } from "child_process";
+import { randomUUID as randomUUID4 } from "crypto";
 
 // src/managers/github-token-manager.ts
 import { promises as fs } from "fs";
 import path from "path";
 
+// src/engine-env.ts
+import { homedir } from "os";
+import { join } from "path";
+function readEnv(name) {
+  const value = process.env[name]?.trim();
+  return value ? value : void 0;
+}
+function parsePort(value) {
+  if (!value) {
+    return 3737;
+  }
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error("Invalid engine environment: REPLICAS_ENGINE_PORT must be a positive integer");
+  }
+  return parsed;
+}
+function requireDefined(value, name) {
+  if (value === void 0 || value === null) {
+    throw new Error(`Invalid engine environment: ${name} is required`);
+  }
+  return value;
+}
+function requireValidURL(value, name) {
+  try {
+    new URL(value);
+    return value;
+  } catch {
+    throw new Error(`Invalid engine environment: ${name} must be a valid URL`);
+  }
+}
+function loadEngineEnv() {
+  const HOME_DIR = readEnv("HOME") ?? homedir();
+  return {
+    // Required boot env.
+    REPLICAS_ENGINE_SECRET: requireDefined(readEnv("REPLICAS_ENGINE_SECRET"), "REPLICAS_ENGINE_SECRET"),
+    WORKSPACE_ID: requireDefined(readEnv("WORKSPACE_ID"), "WORKSPACE_ID"),
+    MONOLITH_URL: requireValidURL(requireDefined(readEnv("MONOLITH_URL"), "MONOLITH_URL"), "MONOLITH_URL"),
+    // Engine config defaults.
+    REPLICAS_ENGINE_PORT: parsePort(readEnv("REPLICAS_ENGINE_PORT")),
+    HOME_DIR,
+    WORKSPACE_ROOT: join(HOME_DIR, "workspaces"),
+    // Engine-consumed optional values.
+    WORKSPACE_NAME: readEnv("WORKSPACE_NAME"),
+    LINEAR_SESSION_ID: readEnv("LINEAR_SESSION_ID"),
+    LINEAR_ACCESS_TOKEN: readEnv("LINEAR_ACCESS_TOKEN"),
+    SLACK_BOT_TOKEN: readEnv("SLACK_BOT_TOKEN"),
+    GH_TOKEN: readEnv("GH_TOKEN"),
+    // Ambient runtime values
+    // not directly used by the engine code, but are required in the VM
+    // for use by the agent or SDKs (e.g claude/codex)
+    ANTHROPIC_API_KEY: readEnv("ANTHROPIC_API_KEY"),
+    CLAUDE_CODE_USE_BEDROCK: readEnv("CLAUDE_CODE_USE_BEDROCK"),
+    AWS_ACCESS_KEY_ID: readEnv("AWS_ACCESS_KEY_ID"),
+    AWS_SECRET_ACCESS_KEY: readEnv("AWS_SECRET_ACCESS_KEY"),
+    AWS_REGION: readEnv("AWS_REGION"),
+    SLACK_CHANNEL_ID: readEnv("SLACK_CHANNEL_ID"),
+    SLACK_THREAD_TS: readEnv("SLACK_THREAD_TS")
+  };
+}
+var ENGINE_ENV = loadEngineEnv();
+
 // src/managers/base-refresh-manager.ts
 var BaseRefreshManager = class {
   constructor(managerName, intervalMs = 45 * 60 * 1e3) {
@@ -64,22 +126,17 @@ var BaseRefreshManager = class {
     return null;
   }
   getRuntimeConfig() {
-    const monolithUrl = process.env.MONOLITH_URL;
-    const workspaceId = process.env.WORKSPACE_ID;
-    const engineSecret = process.env.REPLICAS_ENGINE_SECRET;
-    if (!monolithUrl || !workspaceId || !engineSecret) {
-      return null;
-    }
-    return { monolithUrl, workspaceId, engineSecret };
+    return {
+      monolithUrl: ENGINE_ENV.MONOLITH_URL,
+      workspaceId: ENGINE_ENV.WORKSPACE_ID,
+      engineSecret: ENGINE_ENV.REPLICAS_ENGINE_SECRET
+    };
   }
   getSkipReasonForRun() {
     const skipReason = this.getSkipReason();
     if (skipReason) {
       return skipReason;
     }
-    if (!this.getRuntimeConfig()) {
-      return "missing MONOLITH_URL, WORKSPACE_ID, or REPLICAS_ENGINE_SECRET";
-    }
     return null;
   }
   async refreshOnce() {
@@ -124,15 +181,12 @@ var GitHubTokenManager = class extends BaseRefreshManager {
     }
     const data = await response.json();
     await this.updateGitCredentials(data.token);
+    ENGINE_ENV.GH_TOKEN = data.token;
     process.env.GH_TOKEN = data.token;
     console.log(`[GitHubTokenManager] Token refreshed successfully, expires at ${data.expiresAt}`);
   }
   async updateGitCredentials(token) {
-    const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME;
-    if (!workspaceHome) {
-      console.warn("[GitHubTokenManager] No WORKSPACE_HOME or HOME set, skipping git credentials update");
-      return;
-    }
+    const workspaceHome = ENGINE_ENV.HOME_DIR;
     const credentialsPath = path.join(workspaceHome, ".git-credentials");
     const credentialsContent = `https://x-access-token:${token}@github.com
 `;
@@ -154,7 +208,7 @@ var ClaudeTokenManager = class extends BaseRefreshManager {
     super("ClaudeTokenManager");
   }
   getSkipReason() {
-    if (process.env.ANTHROPIC_API_KEY) {
+    if (ENGINE_ENV.ANTHROPIC_API_KEY) {
       return "ANTHROPIC_API_KEY is set";
     }
     return null;
@@ -178,11 +232,7 @@ var ClaudeTokenManager = class extends BaseRefreshManager {
     console.log(`[ClaudeTokenManager] Credentials refreshed successfully, expires at ${data.expiresAt}`);
   }
   async updateClaudeCredentials(credentials) {
-    const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME;
-    if (!workspaceHome) {
-      console.warn("[ClaudeTokenManager] No WORKSPACE_HOME or HOME set, skipping credentials update");
-      return;
-    }
+    const workspaceHome = ENGINE_ENV.HOME_DIR;
     const claudeDir = path2.join(workspaceHome, ".claude");
     const credentialsPath = path2.join(claudeDir, ".credentials.json");
     const claudeCliConfig = {
@@ -231,11 +281,7 @@ var CodexTokenManager = class extends BaseRefreshManager {
     console.log(`[CodexTokenManager] Credentials refreshed successfully, expires at ${data.expiresAt}`);
   }
   async updateCodexCredentials(credentials) {
-    const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME;
-    if (!workspaceHome) {
-      console.warn("[CodexTokenManager] No WORKSPACE_HOME or HOME set, skipping credentials update");
-      return;
-    }
+    const workspaceHome = ENGINE_ENV.HOME_DIR;
     const codexDir = path3.join(workspaceHome, ".codex");
     const authPath = path3.join(codexDir, "auth.json");
     const codexAuthConfig = {
@@ -259,49 +305,81 @@ var CodexTokenManager = class extends BaseRefreshManager {
 };
 var codexTokenManager = new CodexTokenManager();
 
-// src/services/git-init.ts
+// src/git/service.ts
+import { readdir, stat } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import path4 from "path";
-
-// src/utils/git.ts
-import { execSync } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
+import { join as join3 } from "path";
 
-// src/services/engine-state.ts
+// src/utils/state.ts
 import { readFile, writeFile, mkdir } from "fs/promises";
 import { existsSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-var STATE_DIR = join(homedir(), ".replicas");
-var STATE_FILE = join(STATE_DIR, "engine-state.json");
-var DEFAULT_STATE = {
-  branch: null,
-  prUrl: null,
-  claudeSessionId: null,
-  codexThreadId: null,
-  startHooksCompleted: false
-};
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/utils/type-guards.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
+
+// src/utils/state.ts
+var STATE_DIR = join2(homedir2(), ".replicas");
+var STATE_FILE = join2(STATE_DIR, "engine-state.json");
+var DEFAULT_STATE = {
+  repos: {}
+};
+var stateWriteChain = Promise.resolve();
+function enqueueStateWrite(operation) {
+  const result = stateWriteChain.then(operation);
+  stateWriteChain = result.then(() => void 0, () => void 0);
+  return result;
+}
+async function updateEngineState(updater) {
+  await enqueueStateWrite(async () => {
+    await mkdir(STATE_DIR, { recursive: true });
+    const currentState = await loadEngineState();
+    const nextState = updater(currentState);
+    await writeFile(STATE_FILE, JSON.stringify(nextState, null, 2), "utf-8");
+  });
+}
+function isEngineRepoDiff(value) {
+  return isRecord(value) && typeof value.added === "number" && typeof value.removed === "number";
+}
+function coerceRepoState(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  if (typeof value.name !== "string") return null;
+  if (typeof value.path !== "string") return null;
+  if (typeof value.defaultBranch !== "string") return null;
+  if (typeof value.currentBranch !== "string") return null;
+  if (!(value.prUrl === null || typeof value.prUrl === "string")) return null;
+  if (!(value.gitDiff === null || isEngineRepoDiff(value.gitDiff))) return null;
+  if (typeof value.startHooksCompleted !== "boolean") return null;
+  return {
+    name: value.name,
+    path: value.path,
+    defaultBranch: value.defaultBranch,
+    currentBranch: value.currentBranch,
+    prUrl: value.prUrl,
+    gitDiff: value.gitDiff,
+    startHooksCompleted: value.startHooksCompleted
+  };
+}
 function coerceEngineState(value) {
   if (!isRecord(value)) {
     return {};
   }
   const partial = {};
-  if (value.branch === null || typeof value.branch === "string") {
-    partial.branch = value.branch;
-  }
-  if (value.prUrl === null || typeof value.prUrl === "string") {
-    partial.prUrl = value.prUrl;
-  }
-  if (value.claudeSessionId === null || typeof value.claudeSessionId === "string") {
-    partial.claudeSessionId = value.claudeSessionId;
-  }
-  if (value.codexThreadId === null || typeof value.codexThreadId === "string") {
-    partial.codexThreadId = value.codexThreadId;
-  }
-  if (typeof value.startHooksCompleted === "boolean") {
-    partial.startHooksCompleted = value.startHooksCompleted;
+  if (isRecord(value.repos)) {
+    const repos = {};
+    for (const [repoName, repoState] of Object.entries(value.repos)) {
+      const coerced = coerceRepoState(repoState);
+      if (coerced) {
+        repos[repoName] = coerced;
+      }
+    }
+    partial.repos = repos;
   }
   return partial;
 }
@@ -314,33 +392,38 @@ async function loadEngineState() {
     const state = coerceEngineState(JSON.parse(content));
     return {
       ...DEFAULT_STATE,
-      ...state
+      ...state,
+      repos: state.repos ?? {}
     };
   } catch (error) {
     console.error("[EngineState] Failed to load state, using defaults:", error);
     return { ...DEFAULT_STATE };
   }
 }
-async function saveEngineState(state) {
-  try {
-    await mkdir(STATE_DIR, { recursive: true });
-    const currentState = await loadEngineState();
-    const newState = {
+async function loadRepoState(repoName) {
+  const state = await loadEngineState();
+  return state.repos[repoName] ?? null;
+}
+async function saveRepoState(repoName, state, fallbackState) {
+  await updateEngineState((currentState) => {
+    const currentRepoState = currentState.repos[repoName] ?? fallbackState;
+    return {
       ...currentState,
-      ...state
+      repos: {
+        ...currentState.repos,
+        [repoName]: {
+          ...currentRepoState,
+          ...state
+        }
+      }
     };
-    await writeFile(STATE_FILE, JSON.stringify(newState, null, 2), "utf-8");
-    console.log("[EngineState] State saved:", newState);
-  } catch (error) {
-    console.error("[EngineState] Failed to save state:", error);
-    throw error;
-  }
+  });
 }
 
-// src/utils/git.ts
-var cachedPr = null;
-function runGitCommand(command, cwd) {
-  return execSync(command, {
+// src/git/commands.ts
+import { execFileSync } from "child_process";
+function runGitCommand(args, cwd) {
+  return execFileSync("git", args, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -348,7 +431,7 @@ function runGitCommand(command, cwd) {
 }
 function branchExists(branchName, cwd) {
   try {
-    runGitCommand(`git rev-parse --verify ${branchName}`, cwd);
+    runGitCommand(["rev-parse", "--verify", branchName], cwd);
     return true;
   } catch {
     return false;
@@ -356,229 +439,341 @@ function branchExists(branchName, cwd) {
 }
 function getCurrentBranch(cwd) {
   try {
-    return runGitCommand("git rev-parse --abbrev-ref HEAD", cwd);
+    return runGitCommand(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
   } catch (error) {
     console.error("Error getting current branch:", error);
     return null;
   }
 }
-function getGitDiff(cwd) {
-  try {
-    const defaultBranch = process.env.REPLICAS_DEFAULT_BRANCH || "main";
-    const baseBranch = `origin/${defaultBranch}`;
-    const shortstat = execSync(`git diff ${baseBranch}...HEAD --shortstat -M`, {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    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);
-    }
-    const fullDiff = execSync(`git diff ${baseBranch}...HEAD -M -C`, {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return {
-      added,
-      removed,
-      fullDiff
-    };
-  } catch (error) {
-    console.error("Error getting git diff:", error);
-    return null;
+
+// src/git/service.ts
+var GitService = class {
+  defaultBranchCache = /* @__PURE__ */ new Map();
+  cachedPrByRepo = /* @__PURE__ */ new Map();
+  getWorkspaceRoot() {
+    return ENGINE_ENV.WORKSPACE_ROOT;
   }
-}
-async function getPullRequestUrl(cwd) {
-  try {
-    const currentBranch = getCurrentBranch(cwd);
-    if (!currentBranch) {
-      return null;
+  async listRepositories() {
+    const root = this.getWorkspaceRoot();
+    const rootStat = await this.safeStat(root);
+    if (!rootStat?.isDirectory()) {
+      return [];
     }
-    if (cachedPr && cachedPr.branch === currentBranch) {
-      return cachedPr.prUrl;
+    const entries = await readdir(root);
+    const repos = [];
+    for (const entry of entries) {
+      const fullPath = join3(root, entry);
+      try {
+        const entryStat = await stat(fullPath);
+        if (!entryStat.isDirectory()) {
+          continue;
+        }
+        const hasGit = Boolean(await this.safeStat(join3(fullPath, ".git")));
+        if (!hasGit) {
+          continue;
+        }
+        repos.push({
+          name: entry,
+          path: fullPath,
+          defaultBranch: this.resolveDefaultBranch(fullPath)
+        });
+      } catch {
+      }
     }
-    const persistedState = await loadEngineState();
-    if (persistedState.prUrl && persistedState.branch === currentBranch) {
-      cachedPr = {
-        prUrl: persistedState.prUrl,
-        branch: currentBranch
+    return repos.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  async listRepos(options) {
+    const includeDiffs = options?.includeDiffs === true;
+    if (includeDiffs) {
+      const repos2 = await this.refreshRepos();
+      return repos2.map((repo) => ({
+        ...repo,
+        gitDiff: repo.gitDiff ? { ...repo.gitDiff, fullDiff: this.getFullGitDiff(repo.path, repo.defaultBranch) } : null
+      }));
+    }
+    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 persistedMatchesCurrentBranch = persistedState?.currentBranch === currentBranch;
+        states.push({
+          name: repo.name,
+          path: repo.path,
+          defaultBranch: repo.defaultBranch,
+          currentBranch,
+          prUrl: persistedMatchesCurrentBranch ? persistedState.prUrl : null,
+          gitDiff: persistedMatchesCurrentBranch ? persistedState.gitDiff : null,
+          startHooksCompleted: persistedState?.startHooksCompleted ?? false
+        });
+      } catch {
+      }
+    }
+    return states;
+  }
+  async refreshRepos() {
+    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 startHooksCompleted = persistedState?.startHooksCompleted ?? false;
+        states.push(await this.refreshRepoMetadata(repo, currentBranch, startHooksCompleted, persistedState));
+      } catch {
+      }
+    }
+    return states;
+  }
+  async initializeGitRepository() {
+    const workspaceName = ENGINE_ENV.WORKSPACE_NAME;
+    if (!workspaceName) {
+      return {
+        success: false,
+        repos: [],
+        error: "No WORKSPACE_NAME environment variable set"
       };
-      return cachedPr.prUrl;
     }
-    cachedPr = null;
-    if (persistedState.prUrl && persistedState.branch !== currentBranch) {
-      await saveEngineState({ prUrl: null });
+    const repos = await this.listRepositories();
+    if (repos.length === 0) {
+      return {
+        success: true,
+        repos: []
+      };
     }
+    const results = [];
+    for (const repo of repos) {
+      if (!this.pathExists(repo.path)) {
+        results.push({ name: repo.name, success: true, currentBranch: repo.defaultBranch });
+        continue;
+      }
+      try {
+        const baselineState = {
+          name: repo.name,
+          path: repo.path,
+          defaultBranch: repo.defaultBranch,
+          currentBranch: repo.defaultBranch,
+          prUrl: null,
+          gitDiff: null,
+          startHooksCompleted: false
+        };
+        const persistedState = await loadRepoState(repo.name);
+        const persistedBranch = persistedState?.currentBranch;
+        runGitCommand(["fetch", "--all", "--prune"], repo.path);
+        if (persistedBranch && branchExists(persistedBranch, repo.path)) {
+          const currentBranch = getCurrentBranch(repo.path);
+          if (currentBranch !== persistedBranch) {
+            runGitCommand(["checkout", persistedBranch], repo.path);
+          }
+          results.push({
+            name: repo.name,
+            success: true,
+            currentBranch: persistedBranch,
+            resumed: true
+          });
+          continue;
+        }
+        runGitCommand(["checkout", repo.defaultBranch], repo.path);
+        try {
+          runGitCommand(["pull", "--rebase", "--autostash"], repo.path);
+        } catch {
+        }
+        const branchName = this.findAvailableBranchName(workspaceName, repo.path);
+        runGitCommand(["checkout", "-b", branchName], repo.path);
+        await saveRepoState(repo.name, { currentBranch: branchName, prUrl: null }, baselineState);
+        results.push({
+          name: repo.name,
+          success: true,
+          currentBranch: branchName,
+          resumed: false
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        results.push({
+          name: repo.name,
+          success: false,
+          currentBranch: repo.defaultBranch,
+          error: errorMessage
+        });
+      }
+    }
+    const failed = results.filter((result) => !result.success);
+    return {
+      success: failed.length === 0,
+      repos: results,
+      error: failed.length > 0 ? `Git init failed for ${failed.length} repo(s)` : void 0
+    };
+  }
+  getGitDiffStats(repoPath, defaultBranch) {
     try {
-      const remoteRef = execSync(`git ls-remote --heads origin ${currentBranch}`, {
-        cwd,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
-      if (!remoteRef) {
-        return null;
+      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);
       }
-    } catch {
+      return {
+        added,
+        removed
+      };
+    } catch (error) {
+      console.error("Error getting git diff:", error);
       return null;
     }
+  }
+  getFullGitDiff(repoPath, defaultBranch) {
     try {
-      const prInfo = execSync("gh pr view --json url --jq .url", {
-        cwd,
+      const diffBase = this.getDiffBase(repoPath, defaultBranch);
+      return execFileSync2("git", ["diff", diffBase, "-M", "-C"], {
+        cwd: repoPath,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
-      if (prInfo) {
-        cachedPr = {
-          prUrl: prInfo,
-          branch: currentBranch
-        };
-        await saveEngineState({ prUrl: prInfo });
+      });
+    } catch {
+      return "";
+    }
+  }
+  getDiffBase(repoPath, defaultBranch) {
+    const baseBranch = `origin/${defaultBranch}`;
+    try {
+      return runGitCommand(["merge-base", baseBranch, "HEAD"], repoPath);
+    } catch {
+      return baseBranch;
+    }
+  }
+  async getPullRequestUrl(repoName, repoPath, currentBranchArg, persistedRepoStateArg) {
+    try {
+      const currentBranch = currentBranchArg ?? getCurrentBranch(repoPath);
+      if (!currentBranch) {
+        return null;
+      }
+      const cachedPr = this.cachedPrByRepo.get(repoName);
+      if (cachedPr && cachedPr.currentBranch === currentBranch) {
         return cachedPr.prUrl;
       }
-    } catch {
+      const persistedRepoState = persistedRepoStateArg ?? await loadRepoState(repoName);
+      if (persistedRepoState?.prUrl && persistedRepoState.currentBranch === currentBranch) {
+        this.cachedPrByRepo.set(repoName, {
+          prUrl: persistedRepoState.prUrl,
+          currentBranch
+        });
+        return persistedRepoState.prUrl;
+      }
+      this.cachedPrByRepo.delete(repoName);
+      if (persistedRepoState?.prUrl && persistedRepoState.currentBranch !== currentBranch) {
+        await saveRepoState(repoName, { prUrl: null }, persistedRepoState);
+      }
+      try {
+        const remoteRef = execFileSync2("git", ["ls-remote", "--heads", "origin", currentBranch], {
+          cwd: repoPath,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+        if (!remoteRef) {
+          return null;
+        }
+      } catch {
+        return null;
+      }
+      try {
+        const prInfo = execFileSync2("gh", ["pr", "view", "--json", "url", "--jq", ".url"], {
+          cwd: repoPath,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+        if (prInfo) {
+          this.cachedPrByRepo.set(repoName, {
+            prUrl: prInfo,
+            currentBranch
+          });
+          if (persistedRepoState) {
+            await saveRepoState(repoName, { prUrl: prInfo }, persistedRepoState);
+          }
+          return prInfo;
+        }
+      } catch {
+        return null;
+      }
+      return null;
+    } catch (error) {
+      console.error("Error checking for pull request:", error);
       return null;
     }
-    return null;
-  } catch (error) {
-    console.error("Error checking for pull request:", error);
-    return null;
   }
-}
-async function getGitStatus(workingDirectory) {
-  return {
-    branch: getCurrentBranch(workingDirectory),
-    gitDiff: getGitDiff(workingDirectory),
-    prUrl: await getPullRequestUrl(workingDirectory)
-  };
-}
-
-// src/services/git-init.ts
-var initializedBranch = null;
-function findAvailableBranchName(baseName, cwd) {
-  if (!branchExists(baseName, cwd)) {
-    return baseName;
+  resolveDefaultBranch(repoPath) {
+    const cached = this.defaultBranchCache.get(repoPath);
+    if (cached) {
+      return cached;
+    }
+    const fromSymbolicRef = this.resolveDefaultBranchFromSymbolicRef(repoPath);
+    if (fromSymbolicRef) {
+      this.defaultBranchCache.set(repoPath, fromSymbolicRef);
+      return fromSymbolicRef;
+    }
+    const fallback = "main";
+    this.defaultBranchCache.set(repoPath, fallback);
+    return fallback;
   }
-  return `${baseName}-${Date.now()}`;
-}
-async function initializeGitRepository() {
-  const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME;
-  const repoName = process.env.REPLICAS_REPO_NAME;
-  const workspaceName = process.env.WORKSPACE_NAME;
-  const defaultBranch = process.env.REPLICAS_DEFAULT_BRANCH || "main";
-  if (!workspaceHome) {
-    return {
-      success: false,
-      branch: null,
-      error: "No WORKSPACE_HOME or HOME environment variable set"
-    };
+  resolveDefaultBranchFromSymbolicRef(repoPath) {
+    try {
+      const output = runGitCommand(["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], repoPath);
+      const match = output.match(/^origin\/(.+)$/);
+      return match ? match[1] : null;
+    } catch {
+      return null;
+    }
   }
-  if (!repoName) {
-    console.log("[GitInit] No REPLICAS_REPO_NAME set, skipping git initialization");
-    return {
-      success: true,
-      branch: null
-    };
+  findAvailableBranchName(baseName, cwd) {
+    const sanitizedBaseName = this.sanitizeBranchName(baseName);
+    if (!branchExists(sanitizedBaseName, cwd)) {
+      return sanitizedBaseName;
+    }
+    return `${sanitizedBaseName}-${Date.now()}`;
   }
-  if (!workspaceName) {
-    return {
-      success: false,
-      branch: null,
-      error: "No WORKSPACE_NAME environment variable set"
-    };
+  sanitizeBranchName(name) {
+    const normalized = name.toLowerCase().replace(/[^a-z0-9._/-]+/g, "-").replace(/\/{2,}/g, "/").replace(/^-+|-+$/g, "");
+    return normalized || "replicas";
   }
-  const repoPath = path4.join(workspaceHome, "workspaces", repoName);
-  if (!existsSync2(repoPath)) {
-    console.log(`[GitInit] Repository directory does not exist: ${repoPath}`);
-    console.log("[GitInit] Waiting for initializer to clone the repository...");
-    return {
-      success: true,
-      branch: null
+  async refreshRepoMetadata(repo, currentBranch, startHooksCompleted, persistedState) {
+    const state = {
+      name: repo.name,
+      path: repo.path,
+      defaultBranch: repo.defaultBranch,
+      currentBranch,
+      prUrl: await this.getPullRequestUrl(repo.name, repo.path, currentBranch, persistedState),
+      gitDiff: this.getGitDiffStats(repo.path, repo.defaultBranch),
+      startHooksCompleted
     };
+    await saveRepoState(repo.name, state, state);
+    return state;
   }
-  if (!existsSync2(path4.join(repoPath, ".git"))) {
-    return {
-      success: false,
-      branch: null,
-      error: `Directory exists but is not a git repository: ${repoPath}`
-    };
+  pathExists(path4) {
+    return existsSync2(path4);
   }
-  console.log(`[GitInit] Initializing repository at ${repoPath}`);
-  try {
-    const persistedState = await loadEngineState();
-    const persistedBranch = persistedState.branch;
-    console.log("[GitInit] Fetching all remotes...");
-    runGitCommand("git fetch --all --prune", repoPath);
-    if (persistedBranch && branchExists(persistedBranch, repoPath)) {
-      console.log(`[GitInit] Found persisted branch: ${persistedBranch}`);
-      const currentBranch = getCurrentBranch(repoPath);
-      if (currentBranch === persistedBranch) {
-        console.log(`[GitInit] Already on persisted branch: ${persistedBranch}`);
-        initializedBranch = persistedBranch;
-        return {
-          success: true,
-          branch: persistedBranch,
-          resumed: true
-        };
-      }
-      console.log(`[GitInit] Resuming on persisted branch: ${persistedBranch}`);
-      runGitCommand(`git checkout ${persistedBranch}`, repoPath);
-      initializedBranch = persistedBranch;
-      console.log(`[GitInit] Successfully resumed on branch: ${persistedBranch}`);
-      return {
-        success: true,
-        branch: persistedBranch,
-        resumed: true
-      };
-    }
-    console.log(`[GitInit] Checking out default branch: ${defaultBranch}`);
-    runGitCommand(`git checkout ${defaultBranch}`, repoPath);
-    console.log("[GitInit] Pulling latest changes...");
+  async safeStat(path4) {
     try {
-      runGitCommand("git pull --rebase --autostash", repoPath);
-    } catch (pullError) {
-      console.warn("[GitInit] Pull had issues, continuing anyway:", pullError);
-    }
-    const branchName = findAvailableBranchName(workspaceName, repoPath);
-    if (branchName !== workspaceName) {
-      console.log(`[GitInit] Branch "${workspaceName}" already exists, using "${branchName}" instead`);
-    }
-    console.log(`[GitInit] Creating workspace branch: ${branchName}`);
-    runGitCommand(`git checkout -b ${branchName}`, repoPath);
-    initializedBranch = branchName;
-    await saveEngineState({ branch: branchName, prUrl: null });
-    console.log(`[GitInit] Successfully initialized on branch: ${branchName}`);
-    return {
-      success: true,
-      branch: branchName,
-      resumed: false
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error("[GitInit] Failed to initialize repository:", errorMessage);
-    return {
-      success: false,
-      branch: null,
-      error: errorMessage
-    };
+      return await stat(path4);
+    } catch {
+      return null;
+    }
   }
-}
+};
+var gitService = new GitService();
 
 // src/utils/logger.ts
-import { appendFile, mkdir as mkdir2, readdir, readFile as readFile2, stat, writeFile as writeFile2 } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { basename, join as join2 } from "path";
+import { appendFile, mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
 import { format } from "util";
 import { randomBytes } from "crypto";
-var LOG_DIR = join2(homedir2(), ".replicas", "logs");
-var MAX_READ_LIMIT = 5e3;
+var LOG_DIR = join4(homedir3(), ".replicas", "logs");
 var EngineLogger = class {
   sessionId = null;
   filePath = null;
@@ -587,69 +782,12 @@ var EngineLogger = class {
   async initialize() {
     await mkdir2(LOG_DIR, { recursive: true });
     this.sessionId = this.createSessionId();
-    this.filePath = join2(LOG_DIR, `${this.sessionId}.log`);
+    this.filePath = join4(LOG_DIR, `${this.sessionId}.log`);
     await writeFile2(this.filePath, `=== Replicas Engine Session ${this.sessionId} ===
 `, "utf-8");
     this.patchConsole();
     this.log("INFO", `Engine logging initialized at ${this.filePath}`);
   }
-  getCurrentSessionId() {
-    return this.sessionId;
-  }
-  async listSessions() {
-    await mkdir2(LOG_DIR, { recursive: true });
-    const files = await readdir(LOG_DIR);
-    const sessions = [];
-    for (const file of files) {
-      if (!file.endsWith(".log")) continue;
-      const fullPath = join2(LOG_DIR, file);
-      const fileStat = await stat(fullPath);
-      if (!fileStat.isFile()) continue;
-      sessions.push({
-        sessionId: file.replace(/\.log$/, ""),
-        filename: file,
-        sizeBytes: fileStat.size,
-        updatedAt: fileStat.mtime.toISOString()
-      });
-    }
-    sessions.sort((a, b) => b.filename.localeCompare(a.filename));
-    return sessions;
-  }
-  async readSession(sessionId, options = {}) {
-    const normalized = this.normalizeSessionId(sessionId);
-    const filePath = join2(LOG_DIR, `${normalized}.log`);
-    const content = await readFile2(filePath, "utf-8");
-    const allLines = content.split("\n");
-    if (allLines[allLines.length - 1] === "") {
-      allLines.pop();
-    }
-    const totalLines = allLines.length;
-    const limit = this.normalizeLimit(options.limit);
-    if (options.tail !== void 0) {
-      const tail = Math.max(0, Math.min(MAX_READ_LIMIT, options.tail));
-      const start = Math.max(0, totalLines - tail);
-      const lines2 = allLines.slice(start, start + tail);
-      return {
-        sessionId: normalized,
-        totalLines,
-        offset: start,
-        limit: tail,
-        hasMore: start > 0,
-        lines: lines2
-      };
-    }
-    const offset = Math.max(0, options.offset ?? 0);
-    const lines = allLines.slice(offset, offset + limit);
-    const hasMore = offset + lines.length < totalLines;
-    return {
-      sessionId: normalized,
-      totalLines,
-      offset,
-      limit,
-      hasMore,
-      lines
-    };
-  }
   patchConsole() {
     if (this.patched) return;
     this.patched = true;
@@ -687,69 +825,28 @@ var EngineLogger = class {
     const suffix = randomBytes(3).toString("hex");
     return `${timestamp}-${suffix}`;
   }
-  normalizeLimit(limit) {
-    if (limit === void 0) return 200;
-    if (!Number.isFinite(limit)) return 200;
-    if (limit < 1) return 1;
-    return Math.min(MAX_READ_LIMIT, limit);
-  }
-  normalizeSessionId(sessionId) {
-    const trimmed = sessionId.trim();
-    if (!trimmed || basename(trimmed) !== trimmed || !/^[A-Za-z0-9._-]+$/.test(trimmed)) {
-      throw new Error("Invalid sessionId");
-    }
-    return trimmed;
-  }
 };
 var engineLogger = new EngineLogger();
 
-// src/services/replicas-config.ts
-import { readFile as readFile3, appendFile as appendFile2, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+// src/services/replicas-config-service.ts
+import { readFile as readFile2, appendFile as appendFile2, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
-import { homedir as homedir3 } from "os";
+import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
 import { exec } from "child_process";
 import { promisify } from "util";
-
-// ../shared/src/sandbox.ts
-var SANDBOX_LIFECYCLE = {
-  AUTO_STOP_MINUTES: 60,
-  AUTO_ARCHIVE_MINUTES: 60 * 24 * 7,
-  AUTO_DELETE_MINUTES: -1,
-  SSH_TOKEN_EXPIRATION_MINUTES: 3 * 60
-};
-
-// ../shared/src/prompts.ts
-var GENERAL_INSTRUCTIONS_TAG = "general_instructions";
-function wrapInTag(content, tag) {
-  return `<${tag}>
-${content}
-</${tag}>`;
-}
-
-// ../shared/src/engine/types.ts
-var DEFAULT_CHAT_TITLES = {
-  claude: "Claude Code",
-  codex: "Codex"
-};
-var IMAGE_MEDIA_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
-
-// src/services/replicas-config.ts
 var execAsync = promisify(exec);
-var START_HOOKS_LOG = join3(homedir3(), ".replicas", "startHooks.log");
+var START_HOOKS_LOG = join5(homedir4(), ".replicas", "startHooks.log");
 var START_HOOKS_RUNNING_PROMPT = `IMPORTANT - Start Hooks Running:
-Start hooks are shell commands/scripts set by the repository owners that run on workspace startup.
+Start hooks are shell commands/scripts set by repository owners that run on workspace startup.
 These hooks are currently executing in the background. You can:
 - Check the status and output by reading ~/.replicas/startHooks.log
-- View the hook commands in replicas.json in the repository root (under the "startHook" field)
+- View hook commands in each repository's replicas.json (under the "startHook" field)
 
 The start hooks may install dependencies, build projects, or perform other setup tasks.
 If your task depends on setup being complete, check the log file before proceeding.`;
-function isRecord2(value) {
-  return typeof value === "object" && value !== null;
-}
 function parseReplicasConfig(value) {
-  if (!isRecord2(value)) {
+  if (!isRecord(value)) {
     throw new Error("Invalid replicas.json: expected an object");
   }
   const config = {};
@@ -778,7 +875,7 @@ function parseReplicasConfig(value) {
     config.systemPrompt = value.systemPrompt;
   }
   if ("startHook" in value) {
-    if (!isRecord2(value.startHook)) {
+    if (!isRecord(value.startHook)) {
       throw new Error('Invalid replicas.json: "startHook" must be an object with "commands" array');
     }
     const { commands, timeout } = value.startHook;
@@ -793,151 +890,149 @@ function parseReplicasConfig(value) {
   return config;
 }
 var ReplicasConfigService = class {
-  config = null;
-  workingDirectory;
+  configs = [];
   hooksRunning = false;
   hooksCompleted = false;
   hooksFailed = false;
-  startHooksPromise = null;
-  constructor() {
-    const repoName = process.env.REPLICAS_REPO_NAME;
-    const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME || homedir3();
-    if (repoName) {
-      this.workingDirectory = join3(workspaceHome, "workspaces", repoName);
-    } else {
-      this.workingDirectory = workspaceHome;
-    }
-  }
   /**
-   * Initialize the service by reading replicas.json and starting start hooks asynchronously
-   * Start hooks run in the background and don't block engine startup
+   * Initialize by reading all replicas.json files and running start hooks.
    */
   async initialize() {
-    await this.loadConfig();
-    this.startHooksPromise = this.executeStartHooks();
+    await this.loadConfigs();
+    void this.executeStartHooks().catch((error) => {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.hooksFailed = true;
+      this.hooksRunning = false;
+      console.error("[ReplicasConfig] Start hooks execution failed:", errorMessage);
+    });
   }
   /**
-   * Load and parse the replicas.json config file
+   * Load and parse replicas.json from each discovered repository root.
    */
-  async loadConfig() {
-    const configPath = join3(this.workingDirectory, "replicas.json");
-    if (!existsSync3(configPath)) {
-      console.log("No replicas.json found in workspace directory");
-      this.config = null;
-      return;
-    }
-    try {
-      const data = await readFile3(configPath, "utf-8");
-      const config = parseReplicasConfig(JSON.parse(data));
-      this.config = config;
-      console.log("Loaded replicas.json config:", {
-        hasSystemPrompt: !!config.systemPrompt,
-        startHookCount: config.startHook?.commands.length ?? 0
-      });
-    } catch (error) {
-      if (error instanceof SyntaxError) {
-        console.error("Failed to parse replicas.json:", error.message);
-      } else if (error instanceof Error) {
-        console.error("Error loading replicas.json:", error.message);
+  async loadConfigs() {
+    const repos = await gitService.listRepositories();
+    const configs = [];
+    for (const repo of repos) {
+      const configPath = join5(repo.path, "replicas.json");
+      if (!existsSync3(configPath)) {
+        continue;
+      }
+      try {
+        const data = await readFile2(configPath, "utf-8");
+        const config = parseReplicasConfig(JSON.parse(data));
+        configs.push({
+          repoName: repo.name,
+          workingDirectory: repo.path,
+          defaultBranch: repo.defaultBranch,
+          config
+        });
+      } catch (error) {
+        if (error instanceof SyntaxError) {
+          console.error(`[ReplicasConfig] Failed to parse ${repo.name}/replicas.json:`, error.message);
+        } else if (error instanceof Error) {
+          console.error(`[ReplicasConfig] Error loading ${repo.name}/replicas.json:`, error.message);
+        }
       }
-      this.config = null;
     }
+    this.configs = configs;
   }
   /**
-   * Write a message to the start hooks log file
+   * Write a message to the start hooks log file.
    */
   async logToFile(message) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const logLine = `[${timestamp}] ${message}
 `;
     try {
-      await mkdir3(join3(homedir3(), ".replicas"), { recursive: true });
+      await mkdir3(join5(homedir4(), ".replicas"), { recursive: true });
       await appendFile2(START_HOOKS_LOG, logLine, "utf-8");
     } catch (error) {
       console.error("Failed to write to start hooks log:", error);
     }
   }
   /**
-   * Execute all start hooks defined in replicas.json
-   * Writes output to ~/.replicas/startHooks.log
-   * Only runs once per workspace lifecycle (persisted across sleep/wake cycles)
+   * Execute start hooks from all repositories sequentially.
    */
   async executeStartHooks() {
-    const persistedState = await loadEngineState();
-    if (persistedState.startHooksCompleted) {
-      console.log("Start hooks already completed in previous session, skipping");
+    const hookEntries = this.configs.filter((entry) => entry.config.startHook && entry.config.startHook.commands.length > 0);
+    if (hookEntries.length === 0) {
+      this.hooksRunning = false;
       this.hooksCompleted = true;
       this.hooksFailed = false;
-      await this.logToFile("Start hooks already completed in previous session, skipping");
       return;
     }
-    const startHookConfig = this.config?.startHook;
-    if (!startHookConfig || startHookConfig.commands.length === 0) {
-      this.hooksCompleted = true;
-      this.hooksFailed = false;
-      await saveEngineState({ startHooksCompleted: true });
-      return;
-    }
-    const timeout = startHookConfig.timeout ?? 3e5;
-    const hooks = startHookConfig.commands;
     this.hooksRunning = true;
-    await mkdir3(join3(homedir3(), ".replicas"), { recursive: true });
-    await writeFile3(START_HOOKS_LOG, `=== Start Hooks Execution Log ===
+    this.hooksCompleted = false;
+    try {
+      await mkdir3(join5(homedir4(), ".replicas"), { recursive: true });
+      await writeFile3(
+        START_HOOKS_LOG,
+        `=== Start Hooks Execution Log ===
 Started: ${(/* @__PURE__ */ new Date()).toISOString()}
-Commands: ${hooks.length}
+Repositories: ${hookEntries.length}
 
-`, "utf-8");
-    console.log(`Executing ${hooks.length} start hook(s) with timeout ${timeout}ms...`);
-    await this.logToFile(`Executing ${hooks.length} start hook(s) with timeout ${timeout}ms...`);
-    for (const hook of hooks) {
-      try {
-        console.log(`Running start hook: ${hook}`);
-        await this.logToFile(`
---- Running: ${hook} ---`);
-        const { stdout, stderr } = await execAsync(hook, {
-          cwd: this.workingDirectory,
-          timeout,
-          env: process.env
-        });
-        if (stdout) {
-          console.log(`[${hook}] stdout:`, stdout);
-          await this.logToFile(`[stdout] ${stdout}`);
+`,
+        "utf-8"
+      );
+      for (const entry of hookEntries) {
+        const startHookConfig = entry.config.startHook;
+        if (!startHookConfig) {
+          continue;
         }
-        if (stderr) {
-          console.warn(`[${hook}] stderr:`, stderr);
-          await this.logToFile(`[stderr] ${stderr}`);
+        const persistedRepoState = await loadRepoState(entry.repoName);
+        if (persistedRepoState?.startHooksCompleted) {
+          await this.logToFile(`[${entry.repoName}] Start hooks already completed in this workspace lifecycle, skipping`);
+          continue;
         }
-        console.log(`Start hook completed: ${hook}`);
-        await this.logToFile(`--- Completed: ${hook} ---`);
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        this.hooksFailed = true;
-        console.error(`Start hook failed: ${hook}`, errorMessage);
-        await this.logToFile(`[ERROR] ${hook} failed: ${errorMessage}`);
+        const timeout = startHookConfig.timeout ?? 3e5;
+        await this.logToFile(`[${entry.repoName}] Executing ${startHookConfig.commands.length} hook(s) with timeout ${timeout}ms`);
+        for (const hook of startHookConfig.commands) {
+          try {
+            await this.logToFile(`[${entry.repoName}] --- Running: ${hook} ---`);
+            const { stdout, stderr } = await execAsync(hook, {
+              cwd: entry.workingDirectory,
+              timeout,
+              env: process.env
+            });
+            if (stdout) {
+              await this.logToFile(`[${entry.repoName}] [stdout] ${stdout}`);
+            }
+            if (stderr) {
+              await this.logToFile(`[${entry.repoName}] [stderr] ${stderr}`);
+            }
+            await this.logToFile(`[${entry.repoName}] --- Completed: ${hook} ---`);
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            this.hooksFailed = true;
+            await this.logToFile(`[${entry.repoName}] [ERROR] ${hook} failed: ${errorMessage}`);
+          }
+        }
+        const fallbackRepoState = persistedRepoState ?? {
+          name: entry.repoName,
+          path: entry.workingDirectory,
+          defaultBranch: entry.defaultBranch,
+          currentBranch: entry.defaultBranch,
+          prUrl: null,
+          gitDiff: null,
+          startHooksCompleted: false
+        };
+        await saveRepoState(entry.repoName, { startHooksCompleted: true }, fallbackRepoState);
       }
+      this.hooksCompleted = true;
+      await this.logToFile(`=== All start hooks completed at ${(/* @__PURE__ */ new Date()).toISOString()} ===`);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.hooksFailed = true;
+      this.hooksCompleted = false;
+      console.error("[ReplicasConfig] Start hooks execution failed:", errorMessage);
+      await this.logToFile(`[SYSTEM] [ERROR] Start hooks execution failed: ${errorMessage}`);
+      throw error;
+    } finally {
+      this.hooksRunning = false;
     }
-    this.hooksRunning = false;
-    this.hooksCompleted = true;
-    await saveEngineState({ startHooksCompleted: true });
-    console.log("All start hooks completed");
-    await this.logToFile(`
-=== All start hooks completed at ${(/* @__PURE__ */ new Date()).toISOString()} ===`);
-  }
-  /**
-   * Get the system prompt from replicas.json
-   */
-  getSystemPrompt() {
-    if (!this.config?.systemPrompt) return void 0;
-    return wrapInTag(this.config.systemPrompt, GENERAL_INSTRUCTIONS_TAG);
-  }
-  /**
-   * Get the full config object
-   */
-  getConfig() {
-    return this.config;
   }
   /**
-   * Check if start hooks are currently running
+   * Check if start hooks are currently running.
    */
   areHooksRunning() {
     return this.hooksRunning;
@@ -949,21 +1044,42 @@ Commands: ${hooks.length}
     return this.hooksFailed;
   }
   /**
-   * Get start hook configuration (for system prompt)
+   * Get aggregated start hook metadata.
    */
   getStartHookConfig() {
-    return this.config?.startHook;
+    const commands = this.configs.flatMap((entry) => {
+      const repoCommands = entry.config.startHook?.commands ?? [];
+      return repoCommands.map((command) => `[${entry.repoName}] ${command}`);
+    });
+    if (commands.length === 0) {
+      return void 0;
+    }
+    return { commands };
+  }
+  getSystemPrompts() {
+    const prompts = [];
+    for (const entry of this.configs) {
+      if (typeof entry.config.systemPrompt !== "string") {
+        continue;
+      }
+      const prompt = entry.config.systemPrompt.trim();
+      if (!prompt) {
+        continue;
+      }
+      prompts.push(`[${entry.repoName}] ${prompt}`);
+    }
+    return prompts;
   }
 };
 var replicasConfigService = new ReplicasConfigService();
 
-// src/event-service.ts
+// src/services/event-service.ts
 import { appendFile as appendFile3, mkdir as mkdir4 } from "fs/promises";
-import { homedir as homedir4 } from "os";
-import { join as join4 } from "path";
+import { homedir as homedir5 } from "os";
+import { join as join6 } from "path";
 import { randomUUID } from "crypto";
-var ENGINE_DIR = join4(homedir4(), ".replicas", "engine");
-var EVENTS_FILE = join4(ENGINE_DIR, "events.jsonl");
+var ENGINE_DIR = join6(homedir5(), ".replicas", "engine");
+var EVENTS_FILE = join6(ENGINE_DIR, "events.jsonl");
 var EventService = class {
   subscribers = /* @__PURE__ */ new Map();
   writeChain = Promise.resolve();
@@ -997,98 +1113,46 @@ var EventService = class {
 };
 var eventService = new EventService();
 
-// src/repo-service.ts
-import { readdir as readdir2, stat as stat2 } from "fs/promises";
-import { join as join5 } from "path";
-import { homedir as homedir5 } from "os";
-var RepoService = class {
-  getWorkspaceRoot() {
-    const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME || homedir5();
-    return join5(workspaceHome, "workspaces");
-  }
-  async listRepos() {
-    const root = this.getWorkspaceRoot();
-    const rootStat = await this.safeStat(root);
-    if (!rootStat?.isDirectory()) {
-      return [];
-    }
-    const entries = await readdir2(root);
-    const repos = [];
-    for (const entry of entries) {
-      const fullPath = join5(root, entry);
-      try {
-        const entryStat = await stat2(fullPath);
-        if (!entryStat.isDirectory()) {
-          continue;
-        }
-        const hasGit = Boolean(await this.safeStat(join5(fullPath, ".git")));
-        repos.push({
-          name: entry,
-          path: fullPath,
-          hasGit
-        });
-      } catch {
-      }
-    }
-    return repos.sort((a, b) => a.name.localeCompare(b.name));
-  }
-  async listRepoStatuses() {
-    const repos = await this.listRepos();
-    const statuses = [];
-    for (const repo of repos) {
-      if (!repo.hasGit) {
-        statuses.push({
-          repo,
-          git: {
-            branch: null,
-            prUrl: null,
-            gitDiff: null
-          }
-        });
-        continue;
-      }
-      try {
-        const git = await getGitStatus(repo.path);
-        statuses.push({ repo, git });
-      } catch {
-      }
-    }
-    return statuses;
-  }
-  async safeStat(path5) {
-    try {
-      return await stat2(path5);
-    } catch {
-      return null;
-    }
-  }
-};
-var repoService = new RepoService();
-
-// src/chat-service.ts
-import { mkdir as mkdir7, readFile as readFile6, rm as rm2, writeFile as writeFile5 } from "fs/promises";
-import { homedir as homedir9 } from "os";
+// src/services/chat/chat-service.ts
+import { mkdir as mkdir7, readFile as readFile5, rm, writeFile as writeFile5 } from "fs/promises";
+import { homedir as homedir8 } from "os";
 import { join as join9 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 
+// ../shared/src/sandbox.ts
+var SANDBOX_LIFECYCLE = {
+  AUTO_STOP_MINUTES: 60,
+  AUTO_ARCHIVE_MINUTES: 60 * 24 * 7,
+  AUTO_DELETE_MINUTES: -1,
+  SSH_TOKEN_EXPIRATION_MINUTES: 3 * 60
+};
+
+// ../shared/src/engine/types.ts
+var DEFAULT_CHAT_TITLES = {
+  claude: "Claude Code",
+  codex: "Codex"
+};
+var IMAGE_MEDIA_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
+
+// ../shared/src/routes/workspaces.ts
+var WORKSPACE_FILE_UPLOAD_MAX_SIZE_BYTES = 20 * 1024 * 1024;
+var WORKSPACE_FILE_CONTENT_MAX_SIZE_BYTES = 1 * 1024 * 1024;
+
 // src/managers/claude-manager.ts
 import {
   query
 } from "@anthropic-ai/claude-agent-sdk";
 import { join as join7 } from "path";
-import { mkdir as mkdir5, appendFile as appendFile4, rm } from "fs/promises";
-import { homedir as homedir7 } from "os";
+import { mkdir as mkdir5, appendFile as appendFile4 } from "fs/promises";
+import { homedir as homedir6 } from "os";
 
 // src/utils/jsonl-reader.ts
-import { readFile as readFile4 } from "fs/promises";
-function isRecord3(value) {
-  return typeof value === "object" && value !== null;
-}
+import { readFile as readFile3 } from "fs/promises";
 function isJsonlEvent(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord(value)) {
     return false;
   }
-  return typeof value.timestamp === "string" && typeof value.type === "string" && isRecord3(value.payload);
+  return typeof value.timestamp === "string" && typeof value.type === "string" && isRecord(value.payload);
 }
 function parseJsonlEvents(lines) {
   const events = [];
@@ -1105,52 +1169,23 @@ function parseJsonlEvents(lines) {
 }
 async function readJSONL(filePath) {
   try {
-    const content = await readFile4(filePath, "utf-8");
+    const content = await readFile3(filePath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim());
     return parseJsonlEvents(lines);
   } catch (error) {
     return [];
   }
 }
-async function readJSONLPaginated(filePath, limit, offset = 0) {
-  try {
-    const content = await readFile4(filePath, "utf-8");
-    const lines = content.split("\n").filter((line) => line.trim());
-    const allEvents = parseJsonlEvents(lines);
-    const total = allEvents.length;
-    const startIndex = Math.max(0, total - offset - (limit ?? total));
-    const endIndex = Math.max(0, total - offset);
-    const events = allEvents.slice(startIndex, endIndex);
-    const hasMore = startIndex > 0;
-    return {
-      events,
-      total,
-      hasMore
-    };
-  } catch (error) {
-    return {
-      events: [],
-      total: 0,
-      hasMore: false
-    };
-  }
-}
 
 // src/services/monolith-service.ts
 var MonolithService = class {
   async sendEvent(event) {
-    const monolithUrl = process.env.MONOLITH_URL;
-    const workspaceId = process.env.WORKSPACE_ID;
-    const engineSecret = process.env.REPLICAS_ENGINE_SECRET;
-    if (!monolithUrl || !workspaceId || !engineSecret) {
-      return;
-    }
     try {
-      const response = await fetch(`${monolithUrl}/v1/engine/webhook`, {
+      const response = await fetch(`${ENGINE_ENV.MONOLITH_URL}/v1/engine/webhook`, {
         method: "POST",
         headers: {
-          Authorization: `Bearer ${engineSecret}`,
-          "X-Workspace-Id": workspaceId,
+          Authorization: `Bearer ${ENGINE_ENV.REPLICAS_ENGINE_SECRET}`,
+          "X-Workspace-Id": ENGINE_ENV.WORKSPACE_ID,
           "Content-Type": "application/json"
         },
         body: JSON.stringify(event)
@@ -1166,7 +1201,7 @@ var MonolithService = class {
 };
 var monolithService = new MonolithService();
 
-// src/services/linear-event-converter.ts
+// src/utils/linear-converter.ts
 function linearThoughtToResponse(thought) {
   return {
     linearSessionId: thought.linearSessionId,
@@ -1299,6 +1334,46 @@ function convertClaudeEvent(event, linearSessionId) {
   }
   return null;
 }
+function mapTodoStatus(status) {
+  if (status === "in_progress") {
+    return "inProgress";
+  }
+  if (status === "completed") {
+    return "completed";
+  }
+  if (status === "cancelled" || status === "canceled") {
+    return "canceled";
+  }
+  return "pending";
+}
+function extractPlanFromClaudeEvent(event) {
+  if (event.type !== "assistant") {
+    return null;
+  }
+  const message = event;
+  const contentBlocks = message.message?.content || [];
+  for (const block of contentBlocks) {
+    if (block.type !== "tool_use" || block.name !== "TodoWrite") {
+      continue;
+    }
+    const input = typeof block.input === "string" ? (() => {
+      try {
+        return JSON.parse(block.input);
+      } catch {
+        return null;
+      }
+    })() : typeof block.input === "object" && block.input !== null ? block.input : null;
+    const todos = input?.todos;
+    if (!todos || todos.length === 0) {
+      return null;
+    }
+    return todos.filter((todo) => Boolean(todo.content && todo.content.trim().length > 0)).map((todo) => ({
+      content: todo.content.trim(),
+      status: mapTodoStatus(todo.status)
+    }));
+  }
+  return null;
+}
 function convertCodexEvent(event, linearSessionId) {
   if (event.type === "turn.started") {
     return {
@@ -1485,13 +1560,30 @@ function convertCodexEvent(event, linearSessionId) {
       }
     }
   }
-  return null;
+  return null;
+}
+function extractPlanFromCodexEvent(event) {
+  if (event.type !== "item.started" && event.type !== "item.completed") {
+    return null;
+  }
+  const item = event.item;
+  if (!item || item.type !== "todo_list") {
+    return null;
+  }
+  const items = "items" in item && Array.isArray(item.items) ? item.items : [];
+  if (items.length === 0) {
+    return null;
+  }
+  const hasIncomplete = items.some((entry) => !entry.completed);
+  return items.filter((entry) => Boolean(entry.text && entry.text.trim().length > 0)).map((entry) => ({
+    content: entry.text.trim(),
+    status: entry.completed ? "completed" : hasIncomplete ? "inProgress" : "pending"
+  }));
 }
 
 // src/utils/image-utils.ts
-var IMAGE_MEDIA_TYPES2 = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
 function isImageMediaType(value) {
-  return IMAGE_MEDIA_TYPES2.has(value);
+  return IMAGE_MEDIA_TYPES.includes(value);
 }
 function inferMediaType(url, contentType) {
   if (contentType) {
@@ -1514,13 +1606,13 @@ async function fetchImageAsBase64(url) {
   const headers = {};
   const hostname = new URL(url).hostname;
   if (hostname === "uploads.linear.app") {
-    const token = process.env.LINEAR_TOKEN;
+    const token = ENGINE_ENV.LINEAR_ACCESS_TOKEN;
     if (token) {
       headers["Authorization"] = `Bearer ${token}`;
     }
   }
   if (hostname === "files.slack.com") {
-    const token = process.env.SLACK_BOT_TOKEN;
+    const token = ENGINE_ENV.SLACK_BOT_TOKEN;
     if (token) {
       headers["Authorization"] = `Bearer ${token}`;
     }
@@ -1559,15 +1651,10 @@ async function normalizeImages(images) {
   return normalized;
 }
 
-// src/managers/coding-agent-manager.ts
-import { join as join6 } from "path";
-import { homedir as homedir6 } from "os";
-
-// src/services/message-queue.ts
-var MessageQueue = class {
+// src/services/message-queue-service.ts
+var MessageQueueService = class {
   queue = [];
   processing = false;
-  currentMessageId = null;
   messageIdCounter = 0;
   processMessage;
   constructor(processMessage) {
@@ -1580,15 +1667,11 @@ var MessageQueue = class {
    * Add a message to the queue or start processing immediately if not busy
    * @returns Object indicating whether the message was queued or started processing
    */
-  async enqueue(message, model, customInstructions, images, permissionMode) {
+  async enqueue(request) {
     const messageId = this.generateMessageId();
     const queuedMessage = {
       id: messageId,
-      message,
-      model,
-      customInstructions,
-      images,
-      permissionMode,
+      ...request,
       queuedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     if (this.processing) {
@@ -1608,20 +1691,12 @@ var MessageQueue = class {
   }
   async startProcessing(queuedMessage) {
     this.processing = true;
-    this.currentMessageId = queuedMessage.id;
     try {
-      await this.processMessage(
-        queuedMessage.message,
-        queuedMessage.model,
-        queuedMessage.customInstructions,
-        queuedMessage.images,
-        queuedMessage.permissionMode
-      );
+      await this.processMessage(queuedMessage);
     } catch (error) {
       console.error("[MessageQueue] Error processing message:", error);
     } finally {
       this.processing = false;
-      this.currentMessageId = null;
       await this.processNextInQueue();
     }
   }
@@ -1637,33 +1712,6 @@ var MessageQueue = class {
   isProcessing() {
     return this.processing;
   }
-  /**
-   * Get the current queue length
-   */
-  getQueueLength() {
-    return this.queue.length;
-  }
-  /**
-   * Get full queue status
-   */
-  getStatus() {
-    return {
-      isProcessing: this.processing,
-      queueLength: this.queue.length,
-      currentMessageId: this.currentMessageId,
-      queuedMessages: this.queue.map((msg, index) => ({
-        id: msg.id,
-        queuedAt: msg.queuedAt,
-        position: index + 1
-      }))
-    };
-  }
-  /**
-   * Clear the queue (does not stop current processing)
-   */
-  clearQueue() {
-    this.queue = [];
-  }
   drainQueue(options) {
     const maxItems = options?.maxItems ?? this.queue.length;
     const maxChars = options?.maxChars ?? Number.POSITIVE_INFINITY;
@@ -1685,7 +1733,6 @@ var MessageQueue = class {
   reset() {
     this.queue = [];
     this.processing = false;
-    this.currentMessageId = null;
   }
 };
 
@@ -1696,18 +1743,19 @@ var CodingAgentManager = class {
   workingDirectory;
   messageQueue;
   initialized;
-  baseSystemPrompt;
-  constructor(workingDirectory) {
-    if (workingDirectory) {
-      this.workingDirectory = workingDirectory;
-      return;
-    }
-    const repoName = process.env.REPLICAS_REPO_NAME;
-    const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME || homedir6();
-    this.workingDirectory = repoName ? join6(workspaceHome, "workspaces", repoName) : workspaceHome;
+  initialSessionId;
+  onSaveSessionId;
+  onEvent;
+  onTurnComplete;
+  constructor(options) {
+    this.workingDirectory = options.workingDirectory ?? ENGINE_ENV.WORKSPACE_ROOT;
+    this.initialSessionId = options.initialSessionId;
+    this.onSaveSessionId = options.onSaveSessionId;
+    this.onEvent = options.onEvent;
+    this.onTurnComplete = options.onTurnComplete;
   }
   initializeManager(processMessage) {
-    this.messageQueue = new MessageQueue(processMessage);
+    this.messageQueue = new MessageQueueService(processMessage);
     this.initialized = this.initialize();
   }
   async interrupt() {
@@ -1724,28 +1772,20 @@ var CodingAgentManager = class {
   isProcessing() {
     return this.messageQueue.isProcessing();
   }
-  async enqueueMessage(message, model, customInstructions, images, permissionMode) {
+  async enqueueMessage(request) {
     await this.initialized;
-    return this.messageQueue.enqueue(message, model, customInstructions, images, permissionMode);
-  }
-  getQueueStatus() {
-    return this.messageQueue.getStatus();
-  }
-  setBaseSystemPrompt(prompt) {
-    this.baseSystemPrompt = prompt;
-  }
-  getBaseSystemPrompt() {
-    return this.baseSystemPrompt;
+    return this.messageQueue.enqueue(request);
   }
   buildCombinedInstructions(customInstructions) {
     const startHooksInstruction = this.getStartHooksInstruction();
+    const repositorySystemPromptInstruction = this.getRepositorySystemPromptInstruction();
     const parts = [];
-    if (this.baseSystemPrompt) {
-      parts.push(this.baseSystemPrompt);
-    }
     if (startHooksInstruction) {
       parts.push(startHooksInstruction);
     }
+    if (repositorySystemPromptInstruction) {
+      parts.push(repositorySystemPromptInstruction);
+    }
     if (customInstructions) {
       parts.push(customInstructions);
     }
@@ -1762,7 +1802,7 @@ var CodingAgentManager = class {
     };
   }
   emitInterruptedQueueEvent(queue) {
-    const linearSessionId = process.env.LINEAR_SESSION_ID;
+    const linearSessionId = ENGINE_ENV.LINEAR_SESSION_ID;
     if (!linearSessionId || queue.length === 0) {
       return;
     }
@@ -1777,12 +1817,6 @@ var CodingAgentManager = class {
     monolithService.sendEvent({ type: "agent_update", payload: thoughtEvent }).catch(() => {
     });
   }
-  async emitTurnCompleteEvent() {
-    const linearSessionId = process.env.LINEAR_SESSION_ID;
-    const repoStatuses = await repoService.listRepoStatuses();
-    const payload = linearSessionId ? { linearSessionId, repoStatuses } : { repoStatuses };
-    await monolithService.sendEvent({ type: "agent_turn_complete", payload });
-  }
   getStartHooksInstruction() {
     if (!replicasConfigService.areHooksRunning()) {
       return void 0;
@@ -1793,6 +1827,13 @@ var CodingAgentManager = class {
     }
     return START_HOOKS_RUNNING_PROMPT;
   }
+  getRepositorySystemPromptInstruction() {
+    const repoSystemPrompts = replicasConfigService.getSystemPrompts();
+    if (repoSystemPrompts.length === 0) {
+      return void 0;
+    }
+    return repoSystemPrompts.join("\n");
+  }
 };
 
 // src/managers/claude-manager.ts
@@ -1843,21 +1884,9 @@ var ClaudeManager = class extends CodingAgentManager {
   activeQuery = null;
   activePromptStream = null;
   pendingInterrupt = false;
-  loadSessionId;
-  saveSessionId;
-  onEvent;
   constructor(options) {
-    const normalized = typeof options === "string" ? { workingDirectory: options } : options ?? {};
-    super(normalized.workingDirectory);
-    this.historyFile = normalized.historyFilePath ?? join7(homedir7(), ".replicas", "claude", "history.jsonl");
-    this.loadSessionId = normalized.loadSessionId ?? (async () => {
-      const persistedState = await loadEngineState();
-      return persistedState.claudeSessionId;
-    });
-    this.saveSessionId = normalized.saveSessionId ?? (async (sessionId) => {
-      await saveEngineState({ claudeSessionId: sessionId });
-    });
-    this.onEvent = normalized.onEvent;
+    super(options);
+    this.historyFile = options.historyFilePath ?? join7(homedir6(), ".replicas", "claude", "history.jsonl");
     this.initializeManager(this.processMessageInternal.bind(this));
   }
   async interruptActiveTurn() {
@@ -1867,18 +1896,18 @@ var ClaudeManager = class extends CodingAgentManager {
       await this.activeQuery.interrupt();
     }
   }
-  /**
-   * Legacy sendMessage method - now uses the queue internally
-   * @deprecated Use enqueueMessage for better control over queue status
-   */
-  async sendMessage(message, model, customInstructions, images, permissionMode) {
-    await this.enqueueMessage(message, model, customInstructions, images, permissionMode);
-  }
   /**
    * Internal method that actually processes the message
    */
-  async processMessageInternal(message, model, customInstructions, images, permissionMode) {
-    const linearSessionId = process.env.LINEAR_SESSION_ID;
+  async processMessageInternal(request) {
+    const {
+      message,
+      model,
+      customInstructions,
+      images,
+      permissionMode
+    } = request;
+    const linearSessionId = ENGINE_ENV.LINEAR_SESSION_ID;
     if (!message || !message.trim()) {
       throw new Error("Message cannot be empty");
     }
@@ -1946,6 +1975,14 @@ var ClaudeManager = class extends CodingAgentManager {
       for await (const msg of response) {
         await this.handleMessage(msg);
         if (linearSessionId) {
+          const plan = extractPlanFromClaudeEvent(msg);
+          if (plan) {
+            monolithService.sendEvent({
+              type: "agent_plan_update",
+              payload: { linearSessionId, plan }
+            }).catch(() => {
+            });
+          }
           const linearEvent = convertClaudeEvent(msg, linearSessionId);
           if (linearEvent) {
             if (latestThoughtEvent) {
@@ -1975,7 +2012,7 @@ var ClaudeManager = class extends CodingAgentManager {
       this.activePromptStream?.close();
       this.activePromptStream = null;
       this.pendingInterrupt = false;
-      await this.emitTurnCompleteEvent();
+      await this.onTurnComplete();
     }
   }
   async getHistory() {
@@ -1986,61 +2023,18 @@ var ClaudeManager = class extends CodingAgentManager {
       events
     };
   }
-  /**
-   * Get paginated history from the end (bottom-up pagination).
-   * @param limit - Maximum number of events to return
-   * @param offset - Number of events to skip from the end
-   * @returns Paginated history result
-   */
-  async getHistoryPaginated(limit, offset = 0) {
-    await this.initialized;
-    const result = await readJSONLPaginated(this.historyFile, limit, offset);
-    return {
-      thread_id: this.sessionId,
-      events: result.events,
-      total: result.total,
-      hasMore: result.hasMore
-    };
-  }
-  async getStatus() {
-    await this.initialized;
-    const status = {
-      has_active_thread: this.messageQueue.isProcessing(),
-      thread_id: this.sessionId,
-      working_directory: this.workingDirectory
-    };
-    return status;
-  }
-  async getUpdates(since) {
-    await this.initialized;
-    const allEvents = await readJSONL(this.historyFile);
-    const events = allEvents.filter((event) => event.timestamp > since);
-    const isComplete = !this.messageQueue.isProcessing();
-    return { events, isComplete };
-  }
-  async reset() {
-    await this.initialized;
-    this.sessionId = null;
-    this.messageQueue.reset();
-    await this.saveSessionId(null);
-    try {
-      await rm(this.historyFile, { force: true });
-    } catch {
-    }
-  }
   async initialize() {
-    const historyDir = join7(homedir7(), ".replicas", "claude");
+    const historyDir = join7(homedir6(), ".replicas", "claude");
     await mkdir5(historyDir, { recursive: true });
-    const persistedSessionId = await this.loadSessionId();
-    if (persistedSessionId) {
-      this.sessionId = persistedSessionId;
+    if (this.initialSessionId) {
+      this.sessionId = this.initialSessionId;
       console.log(`[ClaudeManager] Restored session ID from persisted state: ${this.sessionId}`);
     }
   }
   async handleMessage(message) {
     if ("session_id" in message && message.session_id && !this.sessionId) {
       this.sessionId = message.session_id;
-      await this.saveSessionId(this.sessionId);
+      await this.onSaveSessionId(this.sessionId);
       console.log(`[ClaudeManager] Captured and persisted session ID: ${this.sessionId}`);
     }
     await this.recordEvent(message);
@@ -2053,68 +2047,28 @@ var ClaudeManager = class extends CodingAgentManager {
       payload: event
     };
     await appendFile4(this.historyFile, JSON.stringify(jsonEvent) + "\n", "utf-8");
-    if (this.onEvent) {
-      this.onEvent(jsonEvent);
-    }
-  }
-};
-
-// src/providers/claude-adapter.ts
-var ClaudeAdapter = class {
-  manager;
-  constructor(options) {
-    this.manager = new ClaudeManager({
-      workingDirectory: options.workingDirectory,
-      historyFilePath: options.historyFilePath,
-      loadSessionId: options.loadSessionId,
-      saveSessionId: options.saveSessionId,
-      onEvent: options.onEvent
-    });
-  }
-  async enqueueMessage(input) {
-    return this.manager.enqueueMessage(
-      input.message,
-      input.model,
-      input.customInstructions,
-      input.images,
-      input.permissionMode
-    );
-  }
-  async interrupt() {
-    return this.manager.interrupt();
-  }
-  async reset() {
-    await this.manager.reset();
-  }
-  async getHistory() {
-    return this.manager.getHistory();
-  }
-  isProcessing() {
-    return this.manager.isProcessing();
+    this.onEvent(jsonEvent);
   }
 };
 
 // src/managers/codex-manager.ts
 import { Codex } from "@openai/codex-sdk";
 import { randomUUID as randomUUID2 } from "crypto";
-import { readdir as readdir3, stat as stat3, writeFile as writeFile4, mkdir as mkdir6, readFile as readFile5 } from "fs/promises";
+import { readdir as readdir2, stat as stat2, writeFile as writeFile4, mkdir as mkdir6, readFile as readFile4 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
 import { join as join8 } from "path";
-import { homedir as homedir8 } from "os";
+import { homedir as homedir7 } from "os";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 var DEFAULT_MODEL = "gpt-5.3-codex";
-var CODEX_CONFIG_PATH = join8(homedir8(), ".codex", "config.toml");
-function isRecord4(value) {
-  return typeof value === "object" && value !== null;
-}
+var CODEX_CONFIG_PATH = join8(homedir7(), ".codex", "config.toml");
 function isLinearThoughtEvent2(event) {
   return event.content.type === "thought";
 }
 function isJsonlEvent2(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord(value)) {
     return false;
   }
-  return typeof value.timestamp === "string" && typeof value.type === "string" && isRecord4(value.payload);
+  return typeof value.timestamp === "string" && typeof value.type === "string" && isRecord(value.payload);
 }
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -2125,30 +2079,15 @@ var CodexManager = class extends CodingAgentManager {
   currentThread = null;
   tempImageDir;
   activeAbortController = null;
-  loadThreadId;
-  saveThreadId;
-  onEvent;
-  onTurnComplete;
   constructor(options) {
-    const normalized = typeof options === "string" ? { workingDirectory: options } : options ?? {};
-    super(normalized.workingDirectory);
+    super(options);
     this.codex = new Codex();
-    this.loadThreadId = normalized.loadThreadId ?? (async () => {
-      const persistedState = await loadEngineState();
-      return persistedState.codexThreadId;
-    });
-    this.saveThreadId = normalized.saveThreadId ?? (async (threadId) => {
-      await saveEngineState({ codexThreadId: threadId });
-    });
-    this.onEvent = normalized.onEvent;
-    this.onTurnComplete = normalized.onTurnComplete;
-    this.tempImageDir = join8(homedir8(), ".replicas", "codex", "temp-images");
+    this.tempImageDir = join8(homedir7(), ".replicas", "codex", "temp-images");
     this.initializeManager(this.processMessageInternal.bind(this));
   }
   async initialize() {
-    const persistedThreadId = await this.loadThreadId();
-    if (persistedThreadId) {
-      this.currentThreadId = persistedThreadId;
+    if (this.initialSessionId) {
+      this.currentThreadId = this.initialSessionId;
       console.log(`[CodexManager] Restored thread ID from persisted state: ${this.currentThreadId}`);
     }
   }
@@ -2163,14 +2102,14 @@ var CodexManager = class extends CodingAgentManager {
    */
   async updateCodexConfig(developerInstructions) {
     try {
-      const codexDir = join8(homedir8(), ".codex");
+      const codexDir = join8(homedir7(), ".codex");
       await mkdir6(codexDir, { recursive: true });
       let config = {};
       if (existsSync4(CODEX_CONFIG_PATH)) {
         try {
-          const existingContent = await readFile5(CODEX_CONFIG_PATH, "utf-8");
+          const existingContent = await readFile4(CODEX_CONFIG_PATH, "utf-8");
           const parsed = parseToml(existingContent);
-          if (isRecord4(parsed)) {
+          if (isRecord(parsed)) {
             config = parsed;
           }
         } catch (parseError) {
@@ -2209,8 +2148,15 @@ var CodexManager = class extends CodingAgentManager {
   /**
    * Internal method that actually processes the message
    */
-  async processMessageInternal(message, model, customInstructions, images, permissionMode) {
-    const linearSessionId = process.env.LINEAR_SESSION_ID;
+  async processMessageInternal(request) {
+    const {
+      message,
+      model,
+      customInstructions,
+      images,
+      permissionMode
+    } = request;
+    const linearSessionId = ENGINE_ENV.LINEAR_SESSION_ID;
     let tempImagePaths = [];
     let stopTail = null;
     let abortController = null;
@@ -2240,22 +2186,22 @@ var CodexManager = class extends CodingAgentManager {
         for await (const event of events2) {
           if (event.type === "thread.started") {
             this.currentThreadId = event.thread_id;
-            await this.saveThreadId(this.currentThreadId);
+            await this.onSaveSessionId(this.currentThreadId);
             console.log(`[CodexManager] Captured and persisted thread ID: ${this.currentThreadId}`);
           }
         }
         if (!this.currentThreadId && this.currentThread.id) {
           this.currentThreadId = this.currentThread.id;
-          await this.saveThreadId(this.currentThreadId);
+          await this.onSaveSessionId(this.currentThreadId);
           console.log(`[CodexManager] Captured and persisted thread ID from thread.id: ${this.currentThreadId}`);
         }
       }
-      stopTail = this.onEvent && this.currentThreadId ? await this.startSessionTail(this.currentThreadId, this.onEvent) : null;
+      stopTail = this.currentThreadId ? await this.startSessionTail(this.currentThreadId) : null;
       let input;
       if (tempImagePaths.length > 0) {
         const inputItems = [
           { type: "text", text: message },
-          ...tempImagePaths.map((path5) => ({ type: "local_image", path: path5 }))
+          ...tempImagePaths.map((path4) => ({ type: "local_image", path: path4 }))
         ];
         input = inputItems;
       } else {
@@ -2265,6 +2211,14 @@ var CodexManager = class extends CodingAgentManager {
       let latestThoughtEvent = null;
       for await (const event of events) {
         if (linearSessionId) {
+          const plan = extractPlanFromCodexEvent(event);
+          if (plan) {
+            monolithService.sendEvent({
+              type: "agent_plan_update",
+              payload: { linearSessionId, plan }
+            }).catch(() => {
+            });
+          }
           const linearEvent = convertCodexEvent(event, linearSessionId);
           if (linearEvent) {
             if (latestThoughtEvent) {
@@ -2290,11 +2244,8 @@ var CodexManager = class extends CodingAgentManager {
       if (stopTail) {
         await stopTail();
       }
-      if (!abortController?.signal.aborted) {
-        this.onTurnComplete?.();
-      }
+      await this.onTurnComplete();
       this.activeAbortController = null;
-      await this.emitTurnCompleteEvent();
     }
   }
   async getHistory() {
@@ -2317,84 +2268,9 @@ var CodexManager = class extends CodingAgentManager {
       events
     };
   }
-  /**
-   * Get paginated history from the end (bottom-up pagination).
-   * @param limit - Maximum number of events to return
-   * @param offset - Number of events to skip from the end
-   * @returns Paginated history result
-   */
-  async getHistoryPaginated(limit, offset = 0) {
-    if (!this.currentThreadId) {
-      return {
-        thread_id: null,
-        events: [],
-        total: 0,
-        hasMore: false
-      };
-    }
-    const sessionFile = await this.findSessionFile(this.currentThreadId);
-    if (!sessionFile) {
-      return {
-        thread_id: this.currentThreadId,
-        events: [],
-        total: 0,
-        hasMore: false
-      };
-    }
-    const result = await readJSONLPaginated(sessionFile, limit, offset);
-    return {
-      thread_id: this.currentThreadId,
-      events: result.events,
-      total: result.total,
-      hasMore: result.hasMore
-    };
-  }
-  async getStatus() {
-    let sessionFile = null;
-    if (this.currentThreadId) {
-      sessionFile = await this.findSessionFile(this.currentThreadId);
-    }
-    return {
-      has_active_thread: this.currentThreadId !== null,
-      thread_id: this.currentThreadId,
-      session_file: sessionFile,
-      working_directory: this.workingDirectory
-    };
-  }
-  async reset() {
-    this.currentThread = null;
-    this.currentThreadId = null;
-    this.messageQueue.reset();
-    await this.saveThreadId(null);
-  }
-  getThreadId() {
-    return this.currentThreadId;
-  }
-  async getUpdates(since) {
-    if (!this.currentThreadId) {
-      return {
-        events: [],
-        isComplete: true
-      };
-    }
-    const sessionFile = await this.findSessionFile(this.currentThreadId);
-    if (!sessionFile) {
-      return {
-        events: [],
-        isComplete: true
-      };
-    }
-    const allEvents = await readJSONL(sessionFile);
-    const events = allEvents.filter((event) => event.timestamp > since);
-    const isComplete = allEvents.some((event) => event.type === "turn.completed");
-    return {
-      events,
-      isComplete
-    };
-  }
   // Helper methods for finding session files
   async findSessionFile(threadId) {
-    const sessionsDir = join8(homedir8(), ".codex", "sessions");
+    const sessionsDir = join8(homedir7(), ".codex", "sessions");
     try {
       const now = /* @__PURE__ */ new Date();
       const year = now.getFullYear();
@@ -2420,11 +2296,11 @@ var CodexManager = class extends CodingAgentManager {
   }
   async findFileInDirectory(directory, threadId) {
     try {
-      const files = await readdir3(directory);
+      const files = await readdir2(directory);
       for (const file of files) {
         if (file.endsWith(".jsonl") && file.includes(threadId)) {
           const fullPath = join8(directory, file);
-          const stats = await stat3(fullPath);
+          const stats = await stat2(fullPath);
           if (stats.isFile()) {
             return fullPath;
           }
@@ -2446,7 +2322,7 @@ var CodexManager = class extends CodingAgentManager {
     }
     return null;
   }
-  async startSessionTail(threadId, onEvent) {
+  async startSessionTail(threadId) {
     const sessionFile = await this.waitForSessionFile(threadId);
     if (!sessionFile) {
       return async () => {
@@ -2456,7 +2332,7 @@ var CodexManager = class extends CodingAgentManager {
     const seenLines = /* @__PURE__ */ new Set();
     const seedSeenLines = async () => {
       try {
-        const content = await readFile5(sessionFile, "utf-8");
+        const content = await readFile4(sessionFile, "utf-8");
         const lines = content.split("\n").map((line) => line.trim()).filter(Boolean);
         for (const line of lines) {
           seenLines.add(line);
@@ -2468,7 +2344,7 @@ var CodexManager = class extends CodingAgentManager {
     const pump = async () => {
       let emitted = 0;
       try {
-        const content = await readFile5(sessionFile, "utf-8");
+        const content = await readFile4(sessionFile, "utf-8");
         const lines = content.split("\n");
         const completeLines = content.endsWith("\n") ? lines : lines.slice(0, -1);
         for (const line of completeLines) {
@@ -2480,7 +2356,7 @@ var CodexManager = class extends CodingAgentManager {
           try {
             const parsed = JSON.parse(trimmed);
             if (isJsonlEvent2(parsed)) {
-              onEvent(parsed);
+              this.onEvent(parsed);
               emitted += 1;
             }
           } catch {
@@ -2512,45 +2388,7 @@ var CodexManager = class extends CodingAgentManager {
   }
 };
 
-// src/providers/codex-adapter.ts
-var CodexAdapter = class {
-  manager;
-  constructor(options) {
-    this.manager = new CodexManager({
-      workingDirectory: options.workingDirectory,
-      loadThreadId: options.loadThreadId,
-      saveThreadId: options.saveThreadId,
-      onEvent: options.onEvent,
-      onTurnComplete: options.onTurnComplete
-    });
-  }
-  async enqueueMessage(input) {
-    return this.manager.enqueueMessage(
-      input.message,
-      input.model,
-      input.customInstructions,
-      input.images,
-      input.permissionMode
-    );
-  }
-  async interrupt() {
-    return this.manager.interrupt();
-  }
-  async reset() {
-    await this.manager.reset();
-  }
-  async getHistory() {
-    return this.manager.getHistory();
-  }
-  isProcessing() {
-    return this.manager.isProcessing();
-  }
-};
-
-// src/chat-service.ts
-var ENGINE_DIR2 = join9(homedir9(), ".replicas", "engine");
-var CHATS_FILE = join9(ENGINE_DIR2, "chats.json");
-var CLAUDE_HISTORY_DIR = join9(ENGINE_DIR2, "claude-histories");
+// src/services/chat/errors.ts
 var ChatNotFoundError = class extends Error {
   constructor(chatId) {
     super(`Chat not found: ${chatId}`);
@@ -2575,17 +2413,17 @@ var DuplicateDefaultChatError = class extends Error {
     this.name = "DuplicateDefaultChatError";
   }
 };
-function isRecord5(value) {
-  return typeof value === "object" && value !== null;
-}
+
+// src/services/chat/chat-service.ts
+var ENGINE_DIR2 = join9(homedir8(), ".replicas", "engine");
+var CHATS_FILE = join9(ENGINE_DIR2, "chats.json");
+var CLAUDE_HISTORY_DIR = join9(ENGINE_DIR2, "claude-histories");
 function isPersistedChat(value) {
-  if (!isRecord5(value)) {
+  if (!isRecord(value)) {
     return false;
   }
   const candidate = value;
-  const repoScope = candidate.repoScope;
-  const hasValidRepoScope = repoScope === "all" || Array.isArray(repoScope) && repoScope.every((entry) => typeof entry === "string");
-  return typeof candidate.id === "string" && (candidate.provider === "claude" || candidate.provider === "codex") && typeof candidate.title === "string" && typeof candidate.createdAt === "string" && typeof candidate.updatedAt === "string" && hasValidRepoScope && (candidate.providerSessionId === null || typeof candidate.providerSessionId === "string");
+  return typeof candidate.id === "string" && (candidate.provider === "claude" || candidate.provider === "codex") && typeof candidate.title === "string" && typeof candidate.createdAt === "string" && typeof candidate.updatedAt === "string" && (candidate.providerSessionId === null || typeof candidate.providerSessionId === "string");
 }
 var ChatService = class {
   constructor(workingDirectory) {
@@ -2621,7 +2459,6 @@ var ChatService = class {
       title,
       createdAt: now,
       updatedAt: now,
-      repoScope: request.repoScope ?? "all",
       providerSessionId: null
     };
     const runtime = this.createRuntimeChat(persisted);
@@ -2635,13 +2472,7 @@ var ChatService = class {
   }
   async sendMessage(chatId, request) {
     const chat = this.requireChat(chatId);
-    const result = await chat.provider.enqueueMessage({
-      message: request.message,
-      model: request.model,
-      customInstructions: request.customInstructions,
-      images: request.images,
-      permissionMode: request.permissionMode
-    });
+    const result = await chat.provider.enqueueMessage(request);
     chat.pendingMessageIds.push(result.messageId);
     this.touch(chat);
     await this.publish({
@@ -2654,7 +2485,6 @@ var ChatService = class {
       }
     });
     return {
-      success: true,
       messageId: result.messageId,
       queued: result.queued,
       position: result.position
@@ -2676,12 +2506,6 @@ var ChatService = class {
     });
     return result;
   }
-  async reset(chatId) {
-    const chat = this.requireChat(chatId);
-    await chat.provider.reset();
-    chat.persisted.providerSessionId = null;
-    this.touch(chat);
-  }
   async deleteChat(chatId) {
     const chat = this.requireChat(chatId);
     if (chat.persisted.title === DEFAULT_CHAT_TITLES[chat.persisted.provider]) {
@@ -2694,7 +2518,7 @@ var ChatService = class {
     await this.persistAllChats();
     if (chat.persisted.provider === "claude") {
       const historyFilePath = join9(CLAUDE_HISTORY_DIR, `${chatId}.jsonl`);
-      await rm2(historyFilePath, { force: true });
+      await rm(historyFilePath, { force: true });
     }
     await this.publish({
       type: "chat.deleted",
@@ -2728,50 +2552,25 @@ var ChatService = class {
         payload: { chat: this.toSummary(this.requireChat(persisted.id)) }
       });
     };
-    const provider = persisted.provider === "claude" ? new ClaudeAdapter({
+    const onProviderTurnComplete = async () => {
+      await this.handleTurnFinished(persisted.id);
+    };
+    const onProviderEvent = (event) => {
+      this.handleTurnEvent(persisted.id, event);
+    };
+    const provider = persisted.provider === "claude" ? new ClaudeManager({
       workingDirectory: this.workingDirectory,
       historyFilePath: join9(CLAUDE_HISTORY_DIR, `${persisted.id}.jsonl`),
-      loadSessionId: async () => persisted.providerSessionId,
-      saveSessionId: saveSession,
-      onEvent: (event) => {
-        const runtimeChat = this.chats.get(persisted.id);
-        if (runtimeChat) {
-          this.handleProviderEvent(runtimeChat, event);
-        }
-        this.publish({
-          type: "chat.turn.delta",
-          payload: {
-            chatId: persisted.id,
-            event
-          }
-        }).catch(() => {
-        });
-      }
-    }) : new CodexAdapter({
+      initialSessionId: persisted.providerSessionId,
+      onSaveSessionId: saveSession,
+      onTurnComplete: onProviderTurnComplete,
+      onEvent: onProviderEvent
+    }) : new CodexManager({
       workingDirectory: this.workingDirectory,
-      loadThreadId: async () => persisted.providerSessionId,
-      saveThreadId: saveSession,
-      onTurnComplete: () => {
-        const runtimeChat = this.chats.get(persisted.id);
-        if (!runtimeChat) {
-          return;
-        }
-        this.completeTurn(runtimeChat);
-      },
-      onEvent: (event) => {
-        const runtimeChat = this.chats.get(persisted.id);
-        if (runtimeChat) {
-          this.handleProviderEvent(runtimeChat, event);
-        }
-        this.publish({
-          type: "chat.turn.delta",
-          payload: {
-            chatId: persisted.id,
-            event
-          }
-        }).catch(() => {
-        });
-      }
+      initialSessionId: persisted.providerSessionId,
+      onSaveSessionId: saveSession,
+      onTurnComplete: onProviderTurnComplete,
+      onEvent: onProviderEvent
     });
     return {
       persisted,
@@ -2792,7 +2591,6 @@ var ChatService = class {
       title: chat.persisted.title,
       createdAt: chat.persisted.createdAt,
       updatedAt: chat.persisted.updatedAt,
-      repoScope: chat.persisted.repoScope,
       processing: chat.provider.isProcessing()
     };
   }
@@ -2803,7 +2601,11 @@ var ChatService = class {
     }
     return chat;
   }
-  handleProviderEvent(chat, event) {
+  handleTurnEvent(chatId, event) {
+    const chat = this.getRuntimeChat(chatId);
+    if (!chat) {
+      return;
+    }
     if (!chat.hasActiveTurn && chat.pendingMessageIds.length > 0) {
       const messageId = chat.pendingMessageIds.shift();
       if (!messageId) {
@@ -2819,34 +2621,42 @@ var ChatService = class {
       }).catch(() => {
       });
     }
-    if (this.isTurnCompleteEvent(chat.persisted.provider, event.type)) {
-      this.completeTurn(chat);
-    }
     this.touch(chat);
+    this.publish({
+      type: "chat.turn.delta",
+      payload: {
+        chatId,
+        event
+      }
+    }).catch(() => {
+    });
   }
-  completeTurn(chat) {
+  async handleTurnFinished(chatId) {
+    const chat = this.getRuntimeChat(chatId);
+    if (!chat) {
+      return;
+    }
     if (!chat.hasActiveTurn) {
+      await this.publishAgentTurnCompleteWebhook();
       return;
     }
     chat.hasActiveTurn = false;
     this.publish({
       type: "chat.turn.completed",
       payload: {
-        chatId: chat.persisted.id,
+        chatId,
         isComplete: true
       }
     }).catch(() => {
     });
+    await this.publishAgentTurnCompleteWebhook();
   }
-  isTurnCompleteEvent(provider, eventType) {
-    if (provider === "claude") {
-      return eventType === "claude-result";
-    }
-    return eventType === "turn.completed";
+  getRuntimeChat(chatId) {
+    return this.chats.get(chatId) ?? null;
   }
   async loadChats() {
     try {
-      const content = await readFile6(CHATS_FILE, "utf-8");
+      const content = await readFile5(CHATS_FILE, "utf-8");
       const parsed = JSON.parse(content);
       if (!Array.isArray(parsed)) {
         return [];
@@ -2875,33 +2685,38 @@ var ChatService = class {
     };
     await eventService.publish(event);
   }
+  async publishAgentTurnCompleteWebhook() {
+    const linearSessionId = ENGINE_ENV.LINEAR_SESSION_ID;
+    const repoStatuses = await gitService.refreshRepos();
+    const payload = linearSessionId ? { linearSessionId, repoStatuses } : { repoStatuses };
+    await monolithService.sendEvent({ type: "agent_turn_complete", payload });
+  }
 };
 
 // src/v1-routes.ts
 import { Hono } from "hono";
 import { z } from "zod";
-import { randomUUID as randomUUID4 } from "crypto";
 
-// src/plan-service.ts
-import { readdir as readdir4, readFile as readFile7 } from "fs/promises";
-import { homedir as homedir10 } from "os";
-import { basename as basename2, join as join10 } from "path";
+// src/services/plan-service.ts
+import { readdir as readdir3, readFile as readFile6 } from "fs/promises";
+import { homedir as homedir9 } from "os";
+import { basename, join as join10 } from "path";
 var PLAN_DIRECTORIES = [
-  join10(homedir10(), ".claude", "plans"),
-  join10(homedir10(), ".replicas", "plans")
+  join10(homedir9(), ".claude", "plans"),
+  join10(homedir9(), ".replicas", "plans")
 ];
 function isMarkdownFile(filename) {
   return filename.toLowerCase().endsWith(".md");
 }
 function sanitizePlanFilename(filename) {
-  return basename2(filename);
+  return basename(filename);
 }
 var PlanService = class {
   async listPlans() {
     const planNames = /* @__PURE__ */ new Set();
     for (const directory of PLAN_DIRECTORIES) {
       try {
-        const entries = await readdir4(directory, { withFileTypes: true });
+        const entries = await readdir3(directory, { withFileTypes: true });
         for (const entry of entries) {
           if (!entry.isFile()) {
             continue;
@@ -2924,7 +2739,7 @@ var PlanService = class {
     for (const directory of PLAN_DIRECTORIES) {
       const filePath = join10(directory, safeFilename);
       try {
-        const content = await readFile7(filePath, "utf-8");
+        const content = await readFile6(filePath, "utf-8");
         return { filename: safeFilename, content };
       } catch {
       }
@@ -2937,8 +2752,7 @@ var planService = new PlanService();
 // src/v1-routes.ts
 var createChatSchema = z.object({
   provider: z.enum(["claude", "codex"]),
-  title: z.string().min(1).optional(),
-  repoScope: z.union([z.literal("all"), z.array(z.string().min(1))]).optional()
+  title: z.string().min(1).optional()
 });
 var imageMediaTypeSchema = z.enum(IMAGE_MEDIA_TYPES);
 var sendMessageSchema = z.object({
@@ -3110,39 +2924,15 @@ function createV1Routes(deps) {
       return c.json(jsonError("Failed to interrupt chat", error instanceof Error ? error.message : "Unknown error"), 404);
     }
   });
-  app2.post("/chats/:chatId/reset", async (c) => {
-    try {
-      await deps.chatService.reset(c.req.param("chatId"));
-      return c.json({ success: true });
-    } catch (error) {
-      if (error instanceof ChatNotFoundError) {
-        return c.json(jsonError("Failed to reset chat", error.message), 404);
-      }
-      return c.json(jsonError("Failed to reset chat", error instanceof Error ? error.message : "Unknown error"), 404);
-    }
-  });
   app2.get("/repos", async (c) => {
-    const repos = await repoService.listRepos();
+    const includeDiffs = c.req.query("includeDiffs") === "true";
+    const repos = await gitService.listRepos({ includeDiffs });
     const response = {
       repos,
-      workspaceRoot: repoService.getWorkspaceRoot()
+      workspaceRoot: gitService.getWorkspaceRoot()
     };
     return c.json(response);
   });
-  app2.post("/repos/refresh", async (c) => {
-    const repos = await repoService.listRepos();
-    await eventService.publish({
-      id: randomUUID4(),
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      type: "repo.discovered",
-      payload: { repos }
-    });
-    return c.json({ repos, workspaceRoot: repoService.getWorkspaceRoot() });
-  });
-  app2.get("/repos/status", async (c) => {
-    const repos = await repoService.listRepoStatuses();
-    return c.json({ repos, workspaceRoot: repoService.getWorkspaceRoot() });
-  });
   app2.get("/plans", async (c) => {
     try {
       const plans = await planService.listPlans();
@@ -3189,7 +2979,7 @@ var READY_MESSAGE = "========= REPLICAS WORKSPACE READY ==========";
 var COMPLETION_MESSAGE = "========= REPLICAS WORKSPACE INITIALIZATION COMPLETE ==========";
 function checkActiveSSHSessions() {
   try {
-    const output = execSync2('who | grep -v "^$" | wc -l', { encoding: "utf-8" });
+    const output = execSync('who | grep -v "^$" | wc -l', { encoding: "utf-8" });
     const sessionCount = parseInt(output.trim(), 10);
     return sessionCount > 0;
   } catch {
@@ -3201,10 +2991,7 @@ var bootTimeMs = Date.now();
 var engineReady = false;
 var authMiddleware = async (c, next) => {
   const secret = c.req.header("X-Replicas-Engine-Secret");
-  const expectedSecret = process.env.REPLICAS_ENGINE_SECRET;
-  if (!expectedSecret) {
-    return c.json({ error: "Server configuration error: REPLICAS_ENGINE_SECRET not set" }, 500);
-  }
+  const expectedSecret = ENGINE_ENV.REPLICAS_ENGINE_SECRET;
   if (!secret) {
     return c.json({ error: "Unauthorized: X-Replicas-Engine-Secret header required" }, 401);
   }
@@ -3216,13 +3003,13 @@ var authMiddleware = async (c, next) => {
   }
   await next();
 };
-var chatService = new ChatService(repoService.getWorkspaceRoot());
+var chatService = new ChatService(gitService.getWorkspaceRoot());
 app.get("/health", async (c) => {
   if (!engineReady) {
     return c.json({ status: "initializing", timestamp: (/* @__PURE__ */ new Date()).toISOString() }, 503);
   }
   try {
-    const logContent = await readFile8("/var/log/cloud-init-output.log", "utf-8");
+    const logContent = await readFile7("/var/log/cloud-init-output.log", "utf-8");
     let status;
     if (logContent.includes(COMPLETION_MESSAGE)) {
       status = "active";
@@ -3239,7 +3026,7 @@ app.get("/health", async (c) => {
 app.use("*", authMiddleware);
 app.get("/status", async (c) => {
   try {
-    const repos = await repoService.listRepos();
+    const repos = await gitService.listRepos();
     const status = {
       uptimeSeconds: Math.floor((Date.now() - bootTimeMs) / 1e3),
       hasActiveSSHSessions: checkActiveSSHSessions(),
@@ -3265,22 +3052,43 @@ app.get("/token-refresh/health", async (c) => {
   });
 });
 app.route("/", createV1Routes({ chatService }));
-var port = Number(process.env.PORT) || 3737;
+var port = ENGINE_ENV.REPLICAS_ENGINE_PORT;
 function startStatusBroadcaster() {
   let previousRepoStatus = "";
   let previousHookStatus = "";
   let previousEngineStatus = "";
   let lastHooksRunning = replicasConfigService.areHooksRunning();
   setInterval(() => {
-    repoService.listRepoStatuses().then(async (repos) => {
+    gitService.listRepos().then((repos) => {
       const serialized = JSON.stringify(repos);
       if (serialized !== previousRepoStatus) {
         previousRepoStatus = serialized;
-        await eventService.publish({
-          id: randomUUID5(),
+        eventService.publish({
+          id: randomUUID4(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "repo.status.changed",
           payload: { repos }
+        }).catch(() => {
+        });
+      }
+      const engineStatus = {
+        uptimeSeconds: Math.floor((Date.now() - bootTimeMs) / 1e3),
+        hasActiveSSHSessions: checkActiveSSHSessions(),
+        activeSseClients: eventService.getSubscriberCount(),
+        chatsTotal: chatService.listChats().length,
+        chatsProcessing: chatService.getProcessingCount(),
+        reposTotal: repos.length,
+        hooksRunning: replicasConfigService.areHooksRunning()
+      };
+      const engineStatusJson = JSON.stringify(engineStatus);
+      if (engineStatusJson !== previousEngineStatus) {
+        previousEngineStatus = engineStatusJson;
+        eventService.publish({
+          id: randomUUID4(),
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          type: "engine.status.changed",
+          payload: { status: engineStatus }
+        }).catch(() => {
         });
       }
     }).catch(() => {
@@ -3297,7 +3105,7 @@ function startStatusBroadcaster() {
       previousHookStatus = hookSnapshot;
       if (!lastHooksRunning && hooksRunning) {
         eventService.publish({
-          id: randomUUID5(),
+          id: randomUUID4(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "hooks.started",
           payload: { running: true, completed: false }
@@ -3306,7 +3114,7 @@ function startStatusBroadcaster() {
       }
       if (hooksRunning) {
         eventService.publish({
-          id: randomUUID5(),
+          id: randomUUID4(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "hooks.progress",
           payload: { running: true, completed: false }
@@ -3315,7 +3123,7 @@ function startStatusBroadcaster() {
       }
       if (lastHooksRunning && !hooksRunning && hooksCompleted && !hooksFailed) {
         eventService.publish({
-          id: randomUUID5(),
+          id: randomUUID4(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "hooks.completed",
           payload: { running: false, completed: true }
@@ -3324,7 +3132,7 @@ function startStatusBroadcaster() {
       }
       if (lastHooksRunning && !hooksRunning && hooksFailed) {
         eventService.publish({
-          id: randomUUID5(),
+          id: randomUUID4(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "hooks.failed",
           payload: { running: false, completed: hooksCompleted }
@@ -3332,7 +3140,7 @@ function startStatusBroadcaster() {
         });
       }
       eventService.publish({
-        id: randomUUID5(),
+        id: randomUUID4(),
         ts: (/* @__PURE__ */ new Date()).toISOString(),
         type: "hooks.status",
         payload: {
@@ -3343,29 +3151,6 @@ function startStatusBroadcaster() {
       });
       lastHooksRunning = hooksRunning;
     }
-    repoService.listRepos().then((repos) => {
-      const engineStatus = {
-        uptimeSeconds: Math.floor((Date.now() - bootTimeMs) / 1e3),
-        hasActiveSSHSessions: checkActiveSSHSessions(),
-        activeSseClients: eventService.getSubscriberCount(),
-        chatsTotal: chatService.listChats().length,
-        chatsProcessing: chatService.getProcessingCount(),
-        reposTotal: repos.length,
-        hooksRunning: replicasConfigService.areHooksRunning()
-      };
-      const engineStatusJson = JSON.stringify(engineStatus);
-      if (engineStatusJson !== previousEngineStatus) {
-        previousEngineStatus = engineStatusJson;
-        eventService.publish({
-          id: randomUUID5(),
-          ts: (/* @__PURE__ */ new Date()).toISOString(),
-          type: "engine.status.changed",
-          payload: { status: engineStatus }
-        }).catch(() => {
-        });
-      }
-    }).catch(() => {
-    });
   }, 2e3);
 }
 serve(
@@ -3375,7 +3160,7 @@ serve(
   },
   async (info) => {
     console.log(`Replicas Engine running on port ${info.port}`);
-    const gitResult = await initializeGitRepository();
+    const gitResult = await gitService.initializeGitRepository();
     if (!gitResult.success) {
       console.warn(`Git initialization warning: ${gitResult.error}`);
     }
@@ -3385,22 +3170,22 @@ serve(
     await githubTokenManager.start();
     await claudeTokenManager.start();
     await codexTokenManager.start();
-    const repos = await repoService.listRepos();
+    const repos = await gitService.listRepos();
     await eventService.publish({
-      id: randomUUID5(),
+      id: randomUUID4(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       type: "repo.discovered",
       payload: { repos }
     });
-    const repoStatuses = await repoService.listRepoStatuses();
+    const repoStatuses = await gitService.listRepos();
     await eventService.publish({
-      id: randomUUID5(),
+      id: randomUUID4(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       type: "repo.status.changed",
       payload: { repos: repoStatuses }
     });
     await eventService.publish({
-      id: randomUUID5(),
+      id: randomUUID4(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       type: "engine.ready",
       payload: { version: "v1" }