replicas-engine 0.1.60 → 0.1.62

package/dist/src/index.js

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
-import "./chunk-ZXMDA7VB.js";
 
 // src/index.ts
 import { serve } from "@hono/node-server";
 import { Hono as Hono2 } from "hono";
-import { readFile as readFile10 } from "fs/promises";
+import { readFile as readFile12 } from "fs/promises";
 import { execSync } from "child_process";
 import { randomUUID as randomUUID5 } from "crypto";
 
@@ -78,7 +77,7 @@ var ENGINE_ENV = loadEngineEnv();
 
 // src/managers/base-refresh-manager.ts
 var BaseRefreshManager = class {
-  constructor(managerName, intervalMs = 45 * 60 * 1e3) {
+  constructor(managerName, intervalMs = 15 * 60 * 1e3) {
     this.managerName = managerName;
     this.intervalMs = intervalMs;
     this.health = {
@@ -228,6 +227,28 @@ var ClaudeTokenManager = class extends BaseRefreshManager {
     await this.updateClaudeCredentials(data);
     console.log(`[ClaudeTokenManager] Credentials refreshed successfully, expires at ${data.expiresAt}`);
   }
+  /**
+   * Re-fetches credentials from the monolith after an auth failure is detected.
+   * With the 1-hour refresh threshold, the monolith will have already
+   * proactively refreshed the token, so this just pulls the latest.
+   *
+   * Returns true if credentials were successfully updated, false otherwise.
+   */
+  async fetchFreshCredentials() {
+    if (this.getSkipReason()) {
+      return false;
+    }
+    const config = this.getRuntimeConfig();
+    if (!config) return false;
+    try {
+      console.log("[ClaudeTokenManager] Fetching fresh credentials from monolith after auth failure...");
+      await this.doRefresh(config);
+      return true;
+    } catch (error) {
+      console.error("[ClaudeTokenManager] Failed to fetch fresh credentials:", error);
+      return false;
+    }
+  }
   async updateClaudeCredentials(credentials) {
     const workspaceHome = ENGINE_ENV.HOME_DIR;
     const claudeDir = path2.join(workspaceHome, ".claude");
@@ -832,13 +853,63 @@ var EngineLogger = class {
 var engineLogger = new EngineLogger();
 
 // src/services/replicas-config-service.ts
-import { readFile as readFile3, appendFile as appendFile2, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
+import { readFile as readFile4, appendFile as appendFile2, writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import { homedir as homedir5 } from "os";
 import { exec } from "child_process";
 import { promisify as promisify2 } from "util";
 
+// ../shared/src/pricing.ts
+var PLANS = {
+  hobby: {
+    id: "hobby",
+    name: "Hobby",
+    monthlyPrice: 0,
+    seatPriceCents: 0,
+    creditsIncluded: 20,
+    features: ["20 hours of usage"]
+  },
+  developer: {
+    id: "developer",
+    name: "Developer",
+    monthlyPrice: 30,
+    seatPriceCents: 3e3,
+    creditsIncluded: 0,
+    features: ["Unlimited usage", "API access ($1/hr)"]
+  },
+  team: {
+    id: "team",
+    name: "Team",
+    monthlyPrice: 120,
+    seatPriceCents: 12e3,
+    creditsIncluded: 0,
+    features: [
+      "Unlimited usage",
+      "API access",
+      "Higher API rate limits",
+      "Warm hooks and pool access",
+      "Optional add-ons for higher resources, warm pools, rate limits, and SOC 2"
+    ]
+  },
+  enterprise: {
+    id: "enterprise",
+    name: "Enterprise",
+    monthlyPrice: 0,
+    seatPriceCents: 0,
+    creditsIncluded: 0,
+    features: [
+      "Unlimited usage",
+      "Custom API rates",
+      "Custom rate limits",
+      "Custom warm hooks and pools",
+      "SOC 2"
+    ]
+  }
+};
+var TEAM_PLAN = PLANS.team;
+var ENTERPRISE_PLAN = PLANS.enterprise;
+
 // ../shared/src/sandbox.ts
 var SANDBOX_LIFECYCLE = {
   AUTO_STOP_MINUTES: 60,
@@ -1131,9 +1202,57 @@ var EnvironmentDetailsService = class {
 };
 var environmentDetailsService = new EnvironmentDetailsService();
 
+// src/services/start-hook-logs-service.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir4, readFile as readFile3, writeFile as writeFile4, readdir as readdir2 } from "fs/promises";
+import { join as join6 } from "path";
+var LOGS_DIR = join6(SANDBOX_PATHS.REPLICAS_DIR, "start-hook-logs");
+function sanitizeFilename(name) {
+  const safe = name.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const hash = createHash("sha256").update(name).digest("hex").slice(0, 8);
+  return `${safe}-${hash}`;
+}
+var StartHookLogsService = class {
+  async ensureDir() {
+    await mkdir4(LOGS_DIR, { recursive: true });
+  }
+  async saveRepoLog(repoName, entry) {
+    await this.ensureDir();
+    const log = { repoName, ...entry };
+    const filename = `repo-${sanitizeFilename(repoName)}.json`;
+    await writeFile4(join6(LOGS_DIR, filename), `${JSON.stringify(log, null, 2)}
+`, "utf-8");
+  }
+  async getAllLogs() {
+    let files;
+    try {
+      files = await readdir2(LOGS_DIR);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return [];
+      }
+      throw err;
+    }
+    const logs = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) {
+        continue;
+      }
+      try {
+        const raw = await readFile3(join6(LOGS_DIR, file), "utf-8");
+        logs.push(JSON.parse(raw));
+      } catch {
+      }
+    }
+    logs.sort((a, b) => a.repoName.localeCompare(b.repoName));
+    return logs;
+  }
+};
+var startHookLogsService = new StartHookLogsService();
+
 // src/services/replicas-config-service.ts
 var execAsync = promisify2(exec);
-var START_HOOKS_LOG = join6(homedir5(), ".replicas", "startHooks.log");
+var START_HOOKS_LOG = join7(homedir5(), ".replicas", "startHooks.log");
 var START_HOOKS_RUNNING_PROMPT = `IMPORTANT - Start Hooks Running:
 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:
@@ -1144,11 +1263,11 @@ The start hooks may install dependencies, build projects, or perform other setup
 If your task depends on setup being complete, check the log file before proceeding.`;
 async function readReplicasConfigFromDir(dirPath) {
   for (const filename of REPLICAS_CONFIG_FILENAMES) {
-    const configPath = join6(dirPath, filename);
+    const configPath = join7(dirPath, filename);
     if (!existsSync4(configPath)) {
       continue;
     }
-    const data = await readFile3(configPath, "utf-8");
+    const data = await readFile4(configPath, "utf-8");
     const config = parseReplicasConfigString(data, filename);
     return { config, filename };
   }
@@ -1208,7 +1327,7 @@ var ReplicasConfigService = class {
     const logLine = `[${timestamp}] ${message}
 `;
     try {
-      await mkdir4(join6(homedir5(), ".replicas"), { recursive: true });
+      await mkdir5(join7(homedir5(), ".replicas"), { recursive: true });
       await appendFile2(START_HOOKS_LOG, logLine, "utf-8");
     } catch (error) {
       console.error("Failed to write to start hooks log:", error);
@@ -1232,8 +1351,8 @@ var ReplicasConfigService = class {
     this.hooksRunning = true;
     this.hooksCompleted = false;
     try {
-      await mkdir4(join6(homedir5(), ".replicas"), { recursive: true });
-      await writeFile4(
+      await mkdir5(join7(homedir5(), ".replicas"), { recursive: true });
+      await writeFile5(
         START_HOOKS_LOG,
         `=== Start Hooks Execution Log ===
 Started: ${(/* @__PURE__ */ new Date()).toISOString()}
@@ -1262,6 +1381,9 @@ Repositories: ${hookEntries.length}
         }
         const timeout = startHookConfig.timeout ?? 3e5;
         let repoFailed = false;
+        let lastExitCode = 0;
+        let repoTimedOut = false;
+        const repoOutput = [];
         await this.logToFile(`[${entry.repoName}] Executing ${startHookConfig.commands.length} hook(s) with timeout ${timeout}ms`);
         for (const hook of startHookConfig.commands) {
           try {
@@ -1272,20 +1394,35 @@ Repositories: ${hookEntries.length}
               env: process.env
             });
             if (stdout) {
+              repoOutput.push(stdout);
               await this.logToFile(`[${entry.repoName}] [stdout] ${stdout}`);
             }
             if (stderr) {
+              repoOutput.push(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";
+            const execError = error;
+            lastExitCode = execError.code ?? 1;
+            if (execError.killed) {
+              repoTimedOut = true;
+            }
             this.hooksFailed = true;
             repoFailed = true;
+            repoOutput.push(`[ERROR] ${hook} failed: ${errorMessage}`);
             await this.logToFile(`[${entry.repoName}] [ERROR] ${hook} failed: ${errorMessage}`);
             await environmentDetailsService.setRepositoryStartHook(entry.repoName, "no");
           }
         }
+        await startHookLogsService.saveRepoLog(entry.repoName, {
+          hookCommands: startHookConfig.commands,
+          output: repoOutput.join("\n"),
+          exitCode: lastExitCode,
+          timedOut: repoTimedOut,
+          executedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
         const fallbackRepoState = persistedRepoState ?? {
           name: entry.repoName,
           path: entry.workingDirectory,
@@ -1354,17 +1491,17 @@ Repositories: ${hookEntries.length}
 var replicasConfigService = new ReplicasConfigService();
 
 // src/services/event-service.ts
-import { appendFile as appendFile3, mkdir as mkdir5 } from "fs/promises";
+import { appendFile as appendFile3, mkdir as mkdir6 } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import { randomUUID } from "crypto";
-var ENGINE_DIR = join7(homedir6(), ".replicas", "engine");
-var EVENTS_FILE = join7(ENGINE_DIR, "events.jsonl");
+var ENGINE_DIR = join8(homedir6(), ".replicas", "engine");
+var EVENTS_FILE = join8(ENGINE_DIR, "events.jsonl");
 var EventService = class {
   subscribers = /* @__PURE__ */ new Map();
   writeChain = Promise.resolve();
   async initialize() {
-    await mkdir5(ENGINE_DIR, { recursive: true });
+    await mkdir6(ENGINE_DIR, { recursive: true });
   }
   subscribe(subscriber) {
     const id = randomUUID();
@@ -1394,7 +1531,7 @@ var EventService = class {
 var eventService = new EventService();
 
 // src/services/preview-service.ts
-import { mkdir as mkdir6, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir7, readFile as readFile5, writeFile as writeFile6 } from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
 import { dirname } from "path";
@@ -1404,7 +1541,7 @@ async function readPreviewsFile() {
     if (!existsSync5(PREVIEW_PORTS_FILE)) {
       return { previews: [] };
     }
-    const raw = await readFile4(PREVIEW_PORTS_FILE, "utf-8");
+    const raw = await readFile5(PREVIEW_PORTS_FILE, "utf-8");
     return JSON.parse(raw);
   } catch {
     return { previews: [] };
@@ -1412,8 +1549,8 @@ async function readPreviewsFile() {
 }
 async function writePreviewsFile(data) {
   const dir = dirname(PREVIEW_PORTS_FILE);
-  await mkdir6(dir, { recursive: true });
-  await writeFile5(PREVIEW_PORTS_FILE, `${JSON.stringify(data, null, 2)}
+  await mkdir7(dir, { recursive: true });
+  await writeFile6(PREVIEW_PORTS_FILE, `${JSON.stringify(data, null, 2)}
 `, "utf-8");
 }
 var PreviewService = class {
@@ -1449,21 +1586,21 @@ var PreviewService = class {
 var previewService = new PreviewService();
 
 // src/services/chat/chat-service.ts
-import { mkdir as mkdir9, readFile as readFile7, rm, writeFile as writeFile7 } from "fs/promises";
+import { mkdir as mkdir10, readFile as readFile8, rm, writeFile as writeFile8 } from "fs/promises";
 import { homedir as homedir9 } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 
 // src/managers/claude-manager.ts
 import {
   query
 } from "@anthropic-ai/claude-agent-sdk";
-import { join as join8 } from "path";
-import { mkdir as mkdir7, appendFile as appendFile4 } from "fs/promises";
+import { join as join9 } from "path";
+import { mkdir as mkdir8, appendFile as appendFile4 } from "fs/promises";
 import { homedir as homedir7 } from "os";
 
 // src/utils/jsonl-reader.ts
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 function isJsonlEvent(value) {
   if (!isRecord(value)) {
     return false;
@@ -1485,7 +1622,7 @@ function parseJsonlEvents(lines) {
 }
 async function readJSONL(filePath) {
   try {
-    const content = await readFile5(filePath, "utf-8");
+    const content = await readFile6(filePath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim());
     return parseJsonlEvents(lines);
   } catch (error) {
@@ -2214,7 +2351,7 @@ var PromptStream = class {
 function isLinearThoughtEvent(event) {
   return event.content.type === "thought";
 }
-var ClaudeManager = class extends CodingAgentManager {
+var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   historyFile;
   sessionId = null;
   activeQuery = null;
@@ -2222,7 +2359,7 @@ var ClaudeManager = class extends CodingAgentManager {
   pendingInterrupt = false;
   constructor(options) {
     super(options);
-    this.historyFile = options.historyFilePath ?? join8(homedir7(), ".replicas", "claude", "history.jsonl");
+    this.historyFile = options.historyFilePath ?? join9(homedir7(), ".replicas", "claude", "history.jsonl");
     this.initializeManager(this.processMessageInternal.bind(this));
   }
   async interruptActiveTurn() {
@@ -2233,9 +2370,28 @@ var ClaudeManager = class extends CodingAgentManager {
     }
   }
   /**
-   * Internal method that actually processes the message
+   * Internal method that actually processes the message.
+   * On auth failure, refreshes credentials and retries once.
    */
   async processMessageInternal(request) {
+    try {
+      await this.executeQuery(request);
+    } catch (error) {
+      if (_ClaudeManager.isAuthError(error)) {
+        console.warn("[ClaudeManager] Auth failure detected, refreshing credentials and retrying...", error);
+        const refreshed = await claudeTokenManager.fetchFreshCredentials();
+        if (refreshed) {
+          await this.executeQuery(request);
+          return;
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * Executes a single query attempt against the Claude Agent SDK.
+   */
+  async executeQuery(request) {
     const {
       message,
       model,
@@ -2351,6 +2507,18 @@ var ClaudeManager = class extends CodingAgentManager {
       await this.onTurnComplete();
     }
   }
+  /**
+   * Determines if an error is an OAuth authentication failure from the Claude SDK.
+   * Known patterns:
+   *  - "Not logged in · Please run /login"
+   *  - "authentication_failed"
+   *  - "unauthorized"
+   */
+  static isAuthError(error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    const lower = msg.toLowerCase();
+    return lower.includes("not logged in") || lower.includes("please run /login") || lower.includes("authentication_failed") || lower.includes("authentication failed");
+  }
   async getHistory() {
     await this.initialized;
     const events = await readJSONL(this.historyFile);
@@ -2360,19 +2528,41 @@ var ClaudeManager = class extends CodingAgentManager {
     };
   }
   async initialize() {
-    const historyDir = join8(homedir7(), ".replicas", "claude");
-    await mkdir7(historyDir, { recursive: true });
+    const historyDir = join9(homedir7(), ".replicas", "claude");
+    await mkdir8(historyDir, { recursive: true });
     if (this.initialSessionId) {
       this.sessionId = this.initialSessionId;
       console.log(`[ClaudeManager] Restored session ID from persisted state: ${this.sessionId}`);
     }
   }
+  /**
+   * Checks if an SDK message indicates an OAuth authentication failure.
+   * When detected, triggers a force-refresh of credentials from the monolith.
+   */
+  async checkForAuthFailure(message) {
+    if (message.type === "assistant" && "error" in message && message.error === "authentication_failed") {
+      console.warn("[ClaudeManager] Detected authentication_failed in assistant message, force-refreshing credentials...");
+      await claudeTokenManager.fetchFreshCredentials();
+      return;
+    }
+    if (message.type === "result" && "is_error" in message && message.is_error && "errors" in message) {
+      const errors = message.errors ?? [];
+      const hasAuthError = errors.some(
+        (err) => err.toLowerCase().includes("authentication") || err.toLowerCase().includes("unauthorized") || err.toLowerCase().includes("not logged in") || err.toLowerCase().includes("login")
+      );
+      if (hasAuthError) {
+        console.warn("[ClaudeManager] Detected auth-related error in result, force-refreshing credentials...");
+        await claudeTokenManager.fetchFreshCredentials();
+      }
+    }
+  }
   async handleMessage(message) {
     if ("session_id" in message && message.session_id && !this.sessionId) {
       this.sessionId = message.session_id;
       await this.onSaveSessionId(this.sessionId);
       console.log(`[ClaudeManager] Captured and persisted session ID: ${this.sessionId}`);
     }
+    await this.checkForAuthFailure(message);
     await this.recordEvent(message);
   }
   async recordEvent(event) {
@@ -2390,13 +2580,13 @@ var ClaudeManager = class extends CodingAgentManager {
 // src/managers/codex-manager.ts
 import { Codex } from "@openai/codex-sdk";
 import { randomUUID as randomUUID3 } from "crypto";
-import { readdir as readdir2, stat as stat2, writeFile as writeFile6, mkdir as mkdir8, readFile as readFile6 } from "fs/promises";
+import { readdir as readdir3, stat as stat2, writeFile as writeFile7, mkdir as mkdir9, readFile as readFile7 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import { homedir as homedir8 } from "os";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 var DEFAULT_MODEL = "gpt-5.4";
-var CODEX_CONFIG_PATH = join9(homedir8(), ".codex", "config.toml");
+var CODEX_CONFIG_PATH = join10(homedir8(), ".codex", "config.toml");
 function isLinearThoughtEvent2(event) {
   return event.content.type === "thought";
 }
@@ -2418,7 +2608,7 @@ var CodexManager = class extends CodingAgentManager {
   constructor(options) {
     super(options);
     this.codex = new Codex();
-    this.tempImageDir = join9(homedir8(), ".replicas", "codex", "temp-images");
+    this.tempImageDir = join10(homedir8(), ".replicas", "codex", "temp-images");
     this.initializeManager(this.processMessageInternal.bind(this));
   }
   async initialize() {
@@ -2438,12 +2628,12 @@ var CodexManager = class extends CodingAgentManager {
    */
   async updateCodexConfig(developerInstructions) {
     try {
-      const codexDir = join9(homedir8(), ".codex");
-      await mkdir8(codexDir, { recursive: true });
+      const codexDir = join10(homedir8(), ".codex");
+      await mkdir9(codexDir, { recursive: true });
       let config = {};
       if (existsSync6(CODEX_CONFIG_PATH)) {
         try {
-          const existingContent = await readFile6(CODEX_CONFIG_PATH, "utf-8");
+          const existingContent = await readFile7(CODEX_CONFIG_PATH, "utf-8");
           const parsed = parseToml(existingContent);
           if (isRecord(parsed)) {
             config = parsed;
@@ -2458,7 +2648,7 @@ var CodexManager = class extends CodingAgentManager {
         delete config.developer_instructions;
       }
       const tomlContent = stringifyToml(config);
-      await writeFile6(CODEX_CONFIG_PATH, tomlContent, "utf-8");
+      await writeFile7(CODEX_CONFIG_PATH, tomlContent, "utf-8");
       console.log("[CodexManager] Updated config.toml with developer_instructions");
     } catch (error) {
       console.error("[CodexManager] Failed to update config.toml:", error);
@@ -2469,14 +2659,14 @@ var CodexManager = class extends CodingAgentManager {
    * @returns Array of temp file paths
    */
   async saveImagesToTempFiles(images) {
-    await mkdir8(this.tempImageDir, { recursive: true });
+    await mkdir9(this.tempImageDir, { recursive: true });
     const tempPaths = [];
     for (const image of images) {
       const ext = image.source.media_type.split("/")[1] || "png";
       const filename = `img_${randomUUID3()}.${ext}`;
-      const filepath = join9(this.tempImageDir, filename);
+      const filepath = join10(this.tempImageDir, filename);
       const buffer = Buffer.from(image.source.data, "base64");
-      await writeFile6(filepath, buffer);
+      await writeFile7(filepath, buffer);
       tempPaths.push(filepath);
     }
     return tempPaths;
@@ -2606,13 +2796,13 @@ var CodexManager = class extends CodingAgentManager {
   }
   // Helper methods for finding session files
   async findSessionFile(threadId) {
-    const sessionsDir = join9(homedir8(), ".codex", "sessions");
+    const sessionsDir = join10(homedir8(), ".codex", "sessions");
     try {
       const now = /* @__PURE__ */ new Date();
       const year = now.getFullYear();
       const month = String(now.getMonth() + 1).padStart(2, "0");
       const day = String(now.getDate()).padStart(2, "0");
-      const todayDir = join9(sessionsDir, String(year), month, day);
+      const todayDir = join10(sessionsDir, String(year), month, day);
       const file = await this.findFileInDirectory(todayDir, threadId);
       if (file) return file;
       for (let daysAgo = 1; daysAgo <= 7; daysAgo++) {
@@ -2621,7 +2811,7 @@ var CodexManager = class extends CodingAgentManager {
         const searchYear = date.getFullYear();
         const searchMonth = String(date.getMonth() + 1).padStart(2, "0");
         const searchDay = String(date.getDate()).padStart(2, "0");
-        const searchDir = join9(sessionsDir, String(searchYear), searchMonth, searchDay);
+        const searchDir = join10(sessionsDir, String(searchYear), searchMonth, searchDay);
         const file2 = await this.findFileInDirectory(searchDir, threadId);
         if (file2) return file2;
       }
@@ -2632,10 +2822,10 @@ var CodexManager = class extends CodingAgentManager {
   }
   async findFileInDirectory(directory, threadId) {
     try {
-      const files = await readdir2(directory);
+      const files = await readdir3(directory);
       for (const file of files) {
         if (file.endsWith(".jsonl") && file.includes(threadId)) {
-          const fullPath = join9(directory, file);
+          const fullPath = join10(directory, file);
           const stats = await stat2(fullPath);
           if (stats.isFile()) {
             return fullPath;
@@ -2668,7 +2858,7 @@ var CodexManager = class extends CodingAgentManager {
     const seenLines = /* @__PURE__ */ new Set();
     const seedSeenLines = async () => {
       try {
-        const content = await readFile6(sessionFile, "utf-8");
+        const content = await readFile7(sessionFile, "utf-8");
         const lines = content.split("\n").map((line) => line.trim()).filter(Boolean);
         for (const line of lines) {
           seenLines.add(line);
@@ -2680,7 +2870,7 @@ var CodexManager = class extends CodingAgentManager {
     const pump = async () => {
       let emitted = 0;
       try {
-        const content = await readFile6(sessionFile, "utf-8");
+        const content = await readFile7(sessionFile, "utf-8");
         const lines = content.split("\n");
         const completeLines = content.endsWith("\n") ? lines : lines.slice(0, -1);
         for (const line of completeLines) {
@@ -2751,9 +2941,9 @@ var DuplicateDefaultChatError = class extends Error {
 };
 
 // src/services/chat/chat-service.ts
-var ENGINE_DIR2 = join10(homedir9(), ".replicas", "engine");
-var CHATS_FILE = join10(ENGINE_DIR2, "chats.json");
-var CLAUDE_HISTORY_DIR = join10(ENGINE_DIR2, "claude-histories");
+var ENGINE_DIR2 = join11(homedir9(), ".replicas", "engine");
+var CHATS_FILE = join11(ENGINE_DIR2, "chats.json");
+var CLAUDE_HISTORY_DIR = join11(ENGINE_DIR2, "claude-histories");
 function isPersistedChat(value) {
   if (!isRecord(value)) {
     return false;
@@ -2768,8 +2958,8 @@ var ChatService = class {
   chats = /* @__PURE__ */ new Map();
   writeChain = Promise.resolve();
   async initialize() {
-    await mkdir9(ENGINE_DIR2, { recursive: true });
-    await mkdir9(CLAUDE_HISTORY_DIR, { recursive: true });
+    await mkdir10(ENGINE_DIR2, { recursive: true });
+    await mkdir10(CLAUDE_HISTORY_DIR, { recursive: true });
     const persisted = await this.loadChats();
     for (const chat of persisted) {
       const runtime = this.createRuntimeChat(chat);
@@ -2865,7 +3055,7 @@ var ChatService = class {
     this.chats.delete(chatId);
     await this.persistAllChats();
     if (chat.persisted.provider === "claude") {
-      const historyFilePath = join10(CLAUDE_HISTORY_DIR, `${chatId}.jsonl`);
+      const historyFilePath = join11(CLAUDE_HISTORY_DIR, `${chatId}.jsonl`);
       await rm(historyFilePath, { force: true });
     }
     await this.publish({
@@ -2908,7 +3098,7 @@ var ChatService = class {
     };
     const provider = persisted.provider === "claude" ? new ClaudeManager({
       workingDirectory: this.workingDirectory,
-      historyFilePath: join10(CLAUDE_HISTORY_DIR, `${persisted.id}.jsonl`),
+      historyFilePath: join11(CLAUDE_HISTORY_DIR, `${persisted.id}.jsonl`),
       initialSessionId: persisted.providerSessionId,
       onSaveSessionId: saveSession,
       onTurnComplete: onProviderTurnComplete,
@@ -3004,7 +3194,7 @@ var ChatService = class {
   }
   async loadChats() {
     try {
-      const content = await readFile7(CHATS_FILE, "utf-8");
+      const content = await readFile8(CHATS_FILE, "utf-8");
       const parsed = JSON.parse(content);
       if (!Array.isArray(parsed)) {
         return [];
@@ -3021,7 +3211,7 @@ var ChatService = class {
     this.writeChain = this.writeChain.catch(() => {
     }).then(async () => {
       const payload = Array.from(this.chats.values()).map((chat) => chat.persisted);
-      await writeFile7(CHATS_FILE, JSON.stringify(payload, null, 2), "utf-8");
+      await writeFile8(CHATS_FILE, JSON.stringify(payload, null, 2), "utf-8");
     });
     await this.writeChain;
   }
@@ -3051,12 +3241,12 @@ import { Hono } from "hono";
 import { z } from "zod";
 
 // src/services/plan-service.ts
-import { readdir as readdir3, readFile as readFile8 } from "fs/promises";
+import { readdir as readdir4, readFile as readFile9 } from "fs/promises";
 import { homedir as homedir10 } from "os";
-import { basename, join as join11 } from "path";
+import { basename, join as join12 } from "path";
 var PLAN_DIRECTORIES = [
-  join11(homedir10(), ".claude", "plans"),
-  join11(homedir10(), ".replicas", "plans")
+  join12(homedir10(), ".claude", "plans"),
+  join12(homedir10(), ".replicas", "plans")
 ];
 function isMarkdownFile(filename) {
   return filename.toLowerCase().endsWith(".md");
@@ -3069,7 +3259,7 @@ var PlanService = class {
     const planNames = /* @__PURE__ */ new Set();
     for (const directory of PLAN_DIRECTORIES) {
       try {
-        const entries = await readdir3(directory, { withFileTypes: true });
+        const entries = await readdir4(directory, { withFileTypes: true });
         for (const entry of entries) {
           if (!entry.isFile()) {
             continue;
@@ -3090,9 +3280,9 @@ var PlanService = class {
       return null;
     }
     for (const directory of PLAN_DIRECTORIES) {
-      const filePath = join11(directory, safeFilename);
+      const filePath = join12(directory, safeFilename);
       try {
-        const content = await readFile8(filePath, "utf-8");
+        const content = await readFile9(filePath, "utf-8");
         return { filename: safeFilename, content };
       } catch {
       }
@@ -3105,9 +3295,78 @@ var planService = new PlanService();
 // src/services/warm-hooks-service.ts
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify3 } from "util";
-import { readFile as readFile9 } from "fs/promises";
+import { readFile as readFile11 } from "fs/promises";
 import { existsSync as existsSync7 } from "fs";
-import { join as join12 } from "path";
+import { join as join14 } from "path";
+
+// src/services/warm-hook-logs-service.ts
+import { createHash as createHash2 } from "crypto";
+import { mkdir as mkdir11, readFile as readFile10, writeFile as writeFile9, readdir as readdir5 } from "fs/promises";
+import { join as join13 } from "path";
+var LOGS_DIR2 = join13(SANDBOX_PATHS.REPLICAS_DIR, "warm-hook-logs");
+function sanitizeFilename2(name) {
+  const safe = name.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const hash = createHash2("sha256").update(name).digest("hex").slice(0, 8);
+  return `${safe}-${hash}`;
+}
+var WarmHookLogsService = class {
+  async ensureDir() {
+    await mkdir11(LOGS_DIR2, { recursive: true });
+  }
+  async saveGlobalHookLog(entry) {
+    await this.ensureDir();
+    const log = {
+      hookType: "global",
+      hookName: "organization",
+      ...entry
+    };
+    await writeFile9(join13(LOGS_DIR2, "global.json"), `${JSON.stringify(log, null, 2)}
+`, "utf-8");
+  }
+  async saveRepoHookLog(repoName, entry) {
+    await this.ensureDir();
+    const log = {
+      hookType: "repository",
+      hookName: repoName,
+      ...entry
+    };
+    const filename = `repo-${sanitizeFilename2(repoName)}.json`;
+    await writeFile9(join13(LOGS_DIR2, filename), `${JSON.stringify(log, null, 2)}
+`, "utf-8");
+  }
+  async getAllLogs() {
+    let files;
+    try {
+      files = await readdir5(LOGS_DIR2);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return [];
+      }
+      throw err;
+    }
+    const logs = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) {
+        continue;
+      }
+      try {
+        const raw = await readFile10(join13(LOGS_DIR2, file), "utf-8");
+        logs.push(JSON.parse(raw));
+      } catch {
+      }
+    }
+    logs.sort((a, b) => {
+      if (a.hookType !== b.hookType) {
+        return a.hookType === "global" ? -1 : 1;
+      }
+      return a.hookName.localeCompare(b.hookName);
+    });
+    return logs;
+  }
+};
+var warmHookLogsService = new WarmHookLogsService();
+
+// src/services/warm-hooks-service.ts
 var execFileAsync2 = promisify3(execFile2);
 async function executeHookScript(params) {
   const timeout = clampWarmHookTimeoutMs(params.timeoutMs);
@@ -3138,12 +3397,12 @@ async function executeHookScript(params) {
 }
 async function readRepoWarmHook(repoPath) {
   for (const filename of REPLICAS_CONFIG_FILENAMES) {
-    const configPath = join12(repoPath, filename);
+    const configPath = join14(repoPath, filename);
     if (!existsSync7(configPath)) {
       continue;
     }
     try {
-      const raw = await readFile9(configPath, "utf-8");
+      const raw = await readFile11(configPath, "utf-8");
       const config = parseReplicasConfigString(raw, filename);
       if (!config.warmHook) {
         return null;
@@ -3189,6 +3448,13 @@ async function runWarmHooks(params) {
     });
     outputBlocks.push(orgResult.output);
     await environmentDetailsService.setGlobalWarmHook(orgResult.exitCode === 0 ? "yes" : "no", orgResult.output);
+    await warmHookLogsService.saveGlobalHookLog({
+      hookScript: orgHook,
+      output: orgResult.output,
+      exitCode: orgResult.exitCode,
+      timedOut: orgResult.timedOut,
+      executedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
     if (orgResult.exitCode !== 0) {
       return {
         exitCode: orgResult.exitCode,
@@ -3209,6 +3475,11 @@ async function runWarmHooks(params) {
       }
     }
     for (const repoHook of repoHooks) {
+      const combinedScript = repoHook.commands.join("\n");
+      const repoOutputBlocks = [];
+      let repoFailed = false;
+      let repoTimedOut = false;
+      let repoExitCode = 0;
       for (const command of repoHook.commands) {
         const repoResult = await executeHookScript({
           label: `repo-warm-hook:${repoHook.repoName}`,
@@ -3217,18 +3488,32 @@ async function runWarmHooks(params) {
           timeoutMs: repoHook.timeoutMs
         });
         outputBlocks.push(repoResult.output);
+        repoOutputBlocks.push(repoResult.output);
         await environmentDetailsService.setRepositoryWarmHook(
           repoHook.repoName,
           repoResult.exitCode === 0 ? "yes" : "no"
         );
         if (repoResult.exitCode !== 0) {
-          return {
-            exitCode: repoResult.exitCode,
-            output: outputBlocks.join("\n\n"),
-            timedOut: repoResult.timedOut
-          };
+          repoFailed = true;
+          repoTimedOut = repoResult.timedOut;
+          repoExitCode = repoResult.exitCode;
+          break;
         }
       }
+      await warmHookLogsService.saveRepoHookLog(repoHook.repoName, {
+        hookScript: combinedScript,
+        output: repoOutputBlocks.join("\n\n"),
+        exitCode: repoFailed ? repoExitCode : 0,
+        timedOut: repoTimedOut,
+        executedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      if (repoFailed) {
+        return {
+          exitCode: repoExitCode,
+          output: outputBlocks.join("\n\n"),
+          timedOut: repoTimedOut
+        };
+      }
     }
   } else {
     const repos = await gitService.listRepositories();
@@ -3526,6 +3811,28 @@ function createV1Routes(deps) {
       );
     }
   });
+  app2.get("/warm-hooks/logs", async (c) => {
+    try {
+      const logs = await warmHookLogsService.getAllLogs();
+      return c.json({ logs });
+    } catch (error) {
+      return c.json(
+        jsonError("Failed to read warm hook logs", error instanceof Error ? error.message : "Unknown error"),
+        500
+      );
+    }
+  });
+  app2.get("/start-hooks/logs", async (c) => {
+    try {
+      const logs = await startHookLogsService.getAllLogs();
+      return c.json({ logs });
+    } catch (error) {
+      return c.json(
+        jsonError("Failed to read start hook logs", error instanceof Error ? error.message : "Unknown error"),
+        500
+      );
+    }
+  });
   app2.post("/workspace-name", async (c) => {
     try {
       const body = setWorkspaceNameSchema.parse(await c.req.json());
@@ -3603,7 +3910,7 @@ app.get("/health", async (c) => {
     return c.json({ status: "initializing", timestamp: (/* @__PURE__ */ new Date()).toISOString() }, 503);
   }
   try {
-    const logContent = await readFile10("/var/log/cloud-init-output.log", "utf-8");
+    const logContent = await readFile12("/var/log/cloud-init-output.log", "utf-8");
     let status;
     if (logContent.includes(COMPLETION_MESSAGE)) {
       status = "active";