replicas-engine 0.1.48 → 0.1.50

package/dist/src/index.js

@@ -5,7 +5,7 @@ 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 { readFile as readFile9 } from "fs/promises";
 import { execSync } from "child_process";
 import { randomUUID as randomUUID4 } from "crypto";
 
@@ -829,13 +829,11 @@ var EngineLogger = class {
 };
 var engineLogger = new EngineLogger();
 
-// src/services/replicas-config-service.ts
-import { readFile as readFile2, appendFile as appendFile2, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+// src/services/environment-details-service.ts
+import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import { join as join5 } from "path";
 import { homedir as homedir4 } from "os";
-import { exec } from "child_process";
-import { promisify } from "util";
+import { join as join5 } from "path";
 
 // ../shared/src/sandbox.ts
 var SANDBOX_LIFECYCLE = {
@@ -898,6 +896,9 @@ function resolveWarmHookConfig(value) {
   };
 }
 
+// ../shared/src/engine/environment.ts
+var REPLICAS_ENGINE_VERSION = "09-03-2026-kipling";
+
 // ../shared/src/engine/types.ts
 var DEFAULT_CHAT_TITLES = {
   claude: "Claude Code",
@@ -909,9 +910,151 @@ var IMAGE_MEDIA_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
 var WORKSPACE_FILE_UPLOAD_MAX_SIZE_BYTES = 20 * 1024 * 1024;
 var WORKSPACE_FILE_CONTENT_MAX_SIZE_BYTES = 1 * 1024 * 1024;
 
+// src/services/environment-details-service.ts
+var REPLICAS_DIR = join5(homedir4(), ".replicas");
+var ENVIRONMENT_DETAILS_FILE = join5(REPLICAS_DIR, "environment-details.json");
+function createExecutionItem(status, details) {
+  return { status, details: details ?? null };
+}
+function createDefaultDetails() {
+  return {
+    engineVersion: REPLICAS_ENGINE_VERSION,
+    globalWarmHookCompleted: createExecutionItem("n/a"),
+    repositories: [],
+    filesUploaded: [],
+    envVarsSet: [],
+    skillsInstalled: [],
+    runtimeEnvVarsSet: [],
+    repositoriesCloned: [],
+    gitIdentityConfigured: false,
+    githubCredentialsConfigured: false,
+    codexAuthConfigured: false,
+    claudeAuthConfigured: false,
+    bedrockAuthConfigured: false,
+    lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function mergeUnique(current, incoming) {
+  if (!incoming || incoming.length === 0) {
+    return current;
+  }
+  return Array.from(/* @__PURE__ */ new Set([...current, ...incoming]));
+}
+function upsertRepositoryStatus(current, incoming) {
+  const byName = new Map(current.map((repository) => [repository.repositoryName, repository]));
+  for (const repository of incoming) {
+    const existing = byName.get(repository.repositoryName);
+    byName.set(repository.repositoryName, {
+      repositoryName: repository.repositoryName,
+      warmHookCompleted: repository.warmHookCompleted !== "n/a" ? repository.warmHookCompleted : existing?.warmHookCompleted ?? "n/a",
+      startHookCompleted: repository.startHookCompleted !== "n/a" ? repository.startHookCompleted : existing?.startHookCompleted ?? "n/a"
+    });
+  }
+  return [...byName.values()].sort((a, b) => a.repositoryName.localeCompare(b.repositoryName));
+}
+var EnvironmentDetailsService = class {
+  async initialize() {
+    const current = await this.readDetails();
+    const repositories = await gitService.listRepositories();
+    const merged = upsertRepositoryStatus(
+      current.repositories,
+      repositories.map((repository) => ({
+        repositoryName: repository.name,
+        warmHookCompleted: "n/a",
+        startHookCompleted: "n/a"
+      }))
+    );
+    await this.writeDetails({
+      ...current,
+      engineVersion: REPLICAS_ENGINE_VERSION,
+      repositories: merged,
+      lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async getDetails() {
+    const current = await this.readDetails();
+    return {
+      ...current,
+      engineVersion: REPLICAS_ENGINE_VERSION
+    };
+  }
+  async track(update) {
+    const current = await this.readDetails();
+    const next = {
+      ...current,
+      engineVersion: REPLICAS_ENGINE_VERSION,
+      globalWarmHookCompleted: update.globalWarmHookCompleted ?? current.globalWarmHookCompleted,
+      repositories: update.repositories ? upsertRepositoryStatus(current.repositories, update.repositories) : current.repositories,
+      filesUploaded: mergeUnique(current.filesUploaded, update.filesUploaded),
+      envVarsSet: mergeUnique(current.envVarsSet, update.envVarsSet),
+      skillsInstalled: mergeUnique(current.skillsInstalled, update.skillsInstalled),
+      runtimeEnvVarsSet: mergeUnique(current.runtimeEnvVarsSet, update.runtimeEnvVarsSet),
+      repositoriesCloned: mergeUnique(current.repositoriesCloned, update.repositoriesCloned),
+      gitIdentityConfigured: update.gitIdentityConfigured ?? current.gitIdentityConfigured,
+      githubCredentialsConfigured: update.githubCredentialsConfigured ?? current.githubCredentialsConfigured,
+      codexAuthConfigured: update.codexAuthConfigured ?? current.codexAuthConfigured,
+      claudeAuthConfigured: update.claudeAuthConfigured ?? current.claudeAuthConfigured,
+      bedrockAuthConfigured: update.bedrockAuthConfigured ?? current.bedrockAuthConfigured,
+      lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.writeDetails(next);
+    return next;
+  }
+  async setGlobalWarmHook(status, details) {
+    await this.track({
+      globalWarmHookCompleted: createExecutionItem(status, details)
+    });
+  }
+  async setRepositoryWarmHook(repositoryName, status) {
+    await this.track({
+      repositories: [{
+        repositoryName,
+        warmHookCompleted: status,
+        startHookCompleted: "n/a"
+      }]
+    });
+  }
+  async setRepositoryStartHook(repositoryName, status) {
+    await this.track({
+      repositories: [{
+        repositoryName,
+        warmHookCompleted: "n/a",
+        startHookCompleted: status
+      }]
+    });
+  }
+  async readDetails() {
+    try {
+      if (!existsSync3(ENVIRONMENT_DETAILS_FILE)) {
+        return createDefaultDetails();
+      }
+      const raw = await readFile2(ENVIRONMENT_DETAILS_FILE, "utf-8");
+      return {
+        ...createDefaultDetails(),
+        ...JSON.parse(raw),
+        engineVersion: REPLICAS_ENGINE_VERSION
+      };
+    } catch {
+      return createDefaultDetails();
+    }
+  }
+  async writeDetails(details) {
+    await mkdir3(REPLICAS_DIR, { recursive: true });
+    await writeFile3(ENVIRONMENT_DETAILS_FILE, `${JSON.stringify(details, null, 2)}
+`, "utf-8");
+  }
+};
+var environmentDetailsService = new EnvironmentDetailsService();
+
 // src/services/replicas-config-service.ts
+import { readFile as readFile3, appendFile as appendFile2, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
+import { exec } from "child_process";
+import { promisify } from "util";
 var execAsync = promisify(exec);
-var START_HOOKS_LOG = join5(homedir4(), ".replicas", "startHooks.log");
+var START_HOOKS_LOG = join6(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:
@@ -991,12 +1134,12 @@ var ReplicasConfigService = class {
     const repos = await gitService.listRepositories();
     const configs = [];
     for (const repo of repos) {
-      const configPath = join5(repo.path, "replicas.json");
-      if (!existsSync3(configPath)) {
+      const configPath = join6(repo.path, "replicas.json");
+      if (!existsSync4(configPath)) {
         continue;
       }
       try {
-        const data = await readFile2(configPath, "utf-8");
+        const data = await readFile3(configPath, "utf-8");
         const config = parseReplicasConfig(JSON.parse(data));
         configs.push({
           repoName: repo.name,
@@ -1022,7 +1165,7 @@ var ReplicasConfigService = class {
     const logLine = `[${timestamp}] ${message}
 `;
     try {
-      await mkdir3(join5(homedir4(), ".replicas"), { recursive: true });
+      await mkdir4(join6(homedir5(), ".replicas"), { recursive: true });
       await appendFile2(START_HOOKS_LOG, logLine, "utf-8");
     } catch (error) {
       console.error("Failed to write to start hooks log:", error);
@@ -1037,13 +1180,17 @@ var ReplicasConfigService = class {
       this.hooksRunning = false;
       this.hooksCompleted = true;
       this.hooksFailed = false;
+      const repos = await gitService.listRepositories();
+      for (const repo of repos) {
+        await environmentDetailsService.setRepositoryStartHook(repo.name, "n/a");
+      }
       return;
     }
     this.hooksRunning = true;
     this.hooksCompleted = false;
     try {
-      await mkdir3(join5(homedir4(), ".replicas"), { recursive: true });
-      await writeFile3(
+      await mkdir4(join6(homedir5(), ".replicas"), { recursive: true });
+      await writeFile4(
         START_HOOKS_LOG,
         `=== Start Hooks Execution Log ===
 Started: ${(/* @__PURE__ */ new Date()).toISOString()}
@@ -1052,6 +1199,13 @@ Repositories: ${hookEntries.length}
 `,
         "utf-8"
       );
+      const repos = await gitService.listRepositories();
+      const reposWithHooks = new Set(hookEntries.map((entry) => entry.repoName));
+      for (const repo of repos) {
+        if (!reposWithHooks.has(repo.name)) {
+          await environmentDetailsService.setRepositoryStartHook(repo.name, "n/a");
+        }
+      }
       for (const entry of hookEntries) {
         const startHookConfig = entry.config.startHook;
         if (!startHookConfig) {
@@ -1060,9 +1214,11 @@ Repositories: ${hookEntries.length}
         const persistedRepoState = await loadRepoState(entry.repoName);
         if (persistedRepoState?.startHooksCompleted) {
           await this.logToFile(`[${entry.repoName}] Start hooks already completed in this workspace lifecycle, skipping`);
+          await environmentDetailsService.setRepositoryStartHook(entry.repoName, "yes");
           continue;
         }
         const timeout = startHookConfig.timeout ?? 3e5;
+        let repoFailed = false;
         await this.logToFile(`[${entry.repoName}] Executing ${startHookConfig.commands.length} hook(s) with timeout ${timeout}ms`);
         for (const hook of startHookConfig.commands) {
           try {
@@ -1082,7 +1238,9 @@ Repositories: ${hookEntries.length}
           } catch (error) {
             const errorMessage = error instanceof Error ? error.message : "Unknown error";
             this.hooksFailed = true;
+            repoFailed = true;
             await this.logToFile(`[${entry.repoName}] [ERROR] ${hook} failed: ${errorMessage}`);
+            await environmentDetailsService.setRepositoryStartHook(entry.repoName, "no");
           }
         }
         const fallbackRepoState = persistedRepoState ?? {
@@ -1095,6 +1253,7 @@ Repositories: ${hookEntries.length}
           startHooksCompleted: false
         };
         await saveRepoState(entry.repoName, { startHooksCompleted: true }, fallbackRepoState);
+        await environmentDetailsService.setRepositoryStartHook(entry.repoName, repoFailed ? "no" : "yes");
       }
       this.hooksCompleted = true;
       await this.logToFile(`=== All start hooks completed at ${(/* @__PURE__ */ new Date()).toISOString()} ===`);
@@ -1152,17 +1311,17 @@ Repositories: ${hookEntries.length}
 var replicasConfigService = new ReplicasConfigService();
 
 // src/services/event-service.ts
-import { appendFile as appendFile3, mkdir as mkdir4 } from "fs/promises";
-import { homedir as homedir5 } from "os";
-import { join as join6 } from "path";
+import { appendFile as appendFile3, mkdir as mkdir5 } from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { join as join7 } from "path";
 import { randomUUID } from "crypto";
-var ENGINE_DIR = join6(homedir5(), ".replicas", "engine");
-var EVENTS_FILE = join6(ENGINE_DIR, "events.jsonl");
+var ENGINE_DIR = join7(homedir6(), ".replicas", "engine");
+var EVENTS_FILE = join7(ENGINE_DIR, "events.jsonl");
 var EventService = class {
   subscribers = /* @__PURE__ */ new Map();
   writeChain = Promise.resolve();
   async initialize() {
-    await mkdir4(ENGINE_DIR, { recursive: true });
+    await mkdir5(ENGINE_DIR, { recursive: true });
   }
   subscribe(subscriber) {
     const id = randomUUID();
@@ -1192,21 +1351,21 @@ var EventService = class {
 var eventService = new EventService();
 
 // 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 { mkdir as mkdir8, readFile as readFile6, rm, writeFile as writeFile6 } from "fs/promises";
+import { homedir as homedir9 } from "os";
+import { join as join10 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 
 // 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 } from "fs/promises";
-import { homedir as homedir6 } from "os";
+import { join as join8 } from "path";
+import { mkdir as mkdir6, appendFile as appendFile4 } from "fs/promises";
+import { homedir as homedir7 } from "os";
 
 // src/utils/jsonl-reader.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 function isJsonlEvent(value) {
   if (!isRecord(value)) {
     return false;
@@ -1228,7 +1387,7 @@ function parseJsonlEvents(lines) {
 }
 async function readJSONL(filePath) {
   try {
-    const content = await readFile3(filePath, "utf-8");
+    const content = await readFile4(filePath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim());
     return parseJsonlEvents(lines);
   } catch (error) {
@@ -1962,7 +2121,7 @@ var ClaudeManager = class extends CodingAgentManager {
   pendingInterrupt = false;
   constructor(options) {
     super(options);
-    this.historyFile = options.historyFilePath ?? join7(homedir6(), ".replicas", "claude", "history.jsonl");
+    this.historyFile = options.historyFilePath ?? join8(homedir7(), ".replicas", "claude", "history.jsonl");
     this.initializeManager(this.processMessageInternal.bind(this));
   }
   async interruptActiveTurn() {
@@ -2100,8 +2259,8 @@ var ClaudeManager = class extends CodingAgentManager {
     };
   }
   async initialize() {
-    const historyDir = join7(homedir6(), ".replicas", "claude");
-    await mkdir5(historyDir, { recursive: true });
+    const historyDir = join8(homedir7(), ".replicas", "claude");
+    await mkdir6(historyDir, { recursive: true });
     if (this.initialSessionId) {
       this.sessionId = this.initialSessionId;
       console.log(`[ClaudeManager] Restored session ID from persisted state: ${this.sessionId}`);
@@ -2130,13 +2289,13 @@ var ClaudeManager = class extends CodingAgentManager {
 // src/managers/codex-manager.ts
 import { Codex } from "@openai/codex-sdk";
 import { randomUUID as randomUUID2 } from "crypto";
-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 homedir7 } from "os";
+import { readdir as readdir2, stat as stat2, writeFile as writeFile5, mkdir as mkdir7, readFile as readFile5 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { join as join9 } 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 = join8(homedir7(), ".codex", "config.toml");
+var CODEX_CONFIG_PATH = join9(homedir8(), ".codex", "config.toml");
 function isLinearThoughtEvent2(event) {
   return event.content.type === "thought";
 }
@@ -2158,7 +2317,7 @@ var CodexManager = class extends CodingAgentManager {
   constructor(options) {
     super(options);
     this.codex = new Codex();
-    this.tempImageDir = join8(homedir7(), ".replicas", "codex", "temp-images");
+    this.tempImageDir = join9(homedir8(), ".replicas", "codex", "temp-images");
     this.initializeManager(this.processMessageInternal.bind(this));
   }
   async initialize() {
@@ -2178,12 +2337,12 @@ var CodexManager = class extends CodingAgentManager {
    */
   async updateCodexConfig(developerInstructions) {
     try {
-      const codexDir = join8(homedir7(), ".codex");
-      await mkdir6(codexDir, { recursive: true });
+      const codexDir = join9(homedir8(), ".codex");
+      await mkdir7(codexDir, { recursive: true });
       let config = {};
-      if (existsSync4(CODEX_CONFIG_PATH)) {
+      if (existsSync5(CODEX_CONFIG_PATH)) {
         try {
-          const existingContent = await readFile4(CODEX_CONFIG_PATH, "utf-8");
+          const existingContent = await readFile5(CODEX_CONFIG_PATH, "utf-8");
           const parsed = parseToml(existingContent);
           if (isRecord(parsed)) {
             config = parsed;
@@ -2198,7 +2357,7 @@ var CodexManager = class extends CodingAgentManager {
         delete config.developer_instructions;
       }
       const tomlContent = stringifyToml(config);
-      await writeFile4(CODEX_CONFIG_PATH, tomlContent, "utf-8");
+      await writeFile5(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);
@@ -2209,14 +2368,14 @@ var CodexManager = class extends CodingAgentManager {
    * @returns Array of temp file paths
    */
   async saveImagesToTempFiles(images) {
-    await mkdir6(this.tempImageDir, { recursive: true });
+    await mkdir7(this.tempImageDir, { recursive: true });
     const tempPaths = [];
     for (const image of images) {
       const ext = image.source.media_type.split("/")[1] || "png";
       const filename = `img_${randomUUID2()}.${ext}`;
-      const filepath = join8(this.tempImageDir, filename);
+      const filepath = join9(this.tempImageDir, filename);
       const buffer = Buffer.from(image.source.data, "base64");
-      await writeFile4(filepath, buffer);
+      await writeFile5(filepath, buffer);
       tempPaths.push(filepath);
     }
     return tempPaths;
@@ -2346,13 +2505,13 @@ var CodexManager = class extends CodingAgentManager {
   }
   // Helper methods for finding session files
   async findSessionFile(threadId) {
-    const sessionsDir = join8(homedir7(), ".codex", "sessions");
+    const sessionsDir = join9(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 = join8(sessionsDir, String(year), month, day);
+      const todayDir = join9(sessionsDir, String(year), month, day);
       const file = await this.findFileInDirectory(todayDir, threadId);
       if (file) return file;
       for (let daysAgo = 1; daysAgo <= 7; daysAgo++) {
@@ -2361,7 +2520,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 = join8(sessionsDir, String(searchYear), searchMonth, searchDay);
+        const searchDir = join9(sessionsDir, String(searchYear), searchMonth, searchDay);
         const file2 = await this.findFileInDirectory(searchDir, threadId);
         if (file2) return file2;
       }
@@ -2375,7 +2534,7 @@ var CodexManager = class extends CodingAgentManager {
       const files = await readdir2(directory);
       for (const file of files) {
         if (file.endsWith(".jsonl") && file.includes(threadId)) {
-          const fullPath = join8(directory, file);
+          const fullPath = join9(directory, file);
           const stats = await stat2(fullPath);
           if (stats.isFile()) {
             return fullPath;
@@ -2408,7 +2567,7 @@ var CodexManager = class extends CodingAgentManager {
     const seenLines = /* @__PURE__ */ new Set();
     const seedSeenLines = async () => {
       try {
-        const content = await readFile4(sessionFile, "utf-8");
+        const content = await readFile5(sessionFile, "utf-8");
         const lines = content.split("\n").map((line) => line.trim()).filter(Boolean);
         for (const line of lines) {
           seenLines.add(line);
@@ -2420,7 +2579,7 @@ var CodexManager = class extends CodingAgentManager {
     const pump = async () => {
       let emitted = 0;
       try {
-        const content = await readFile4(sessionFile, "utf-8");
+        const content = await readFile5(sessionFile, "utf-8");
         const lines = content.split("\n");
         const completeLines = content.endsWith("\n") ? lines : lines.slice(0, -1);
         for (const line of completeLines) {
@@ -2491,9 +2650,9 @@ var DuplicateDefaultChatError = class extends Error {
 };
 
 // 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");
+var ENGINE_DIR2 = join10(homedir9(), ".replicas", "engine");
+var CHATS_FILE = join10(ENGINE_DIR2, "chats.json");
+var CLAUDE_HISTORY_DIR = join10(ENGINE_DIR2, "claude-histories");
 function isPersistedChat(value) {
   if (!isRecord(value)) {
     return false;
@@ -2508,8 +2667,8 @@ var ChatService = class {
   chats = /* @__PURE__ */ new Map();
   writeChain = Promise.resolve();
   async initialize() {
-    await mkdir7(ENGINE_DIR2, { recursive: true });
-    await mkdir7(CLAUDE_HISTORY_DIR, { recursive: true });
+    await mkdir8(ENGINE_DIR2, { recursive: true });
+    await mkdir8(CLAUDE_HISTORY_DIR, { recursive: true });
     const persisted = await this.loadChats();
     for (const chat of persisted) {
       const runtime = this.createRuntimeChat(chat);
@@ -2593,7 +2752,7 @@ var ChatService = class {
     this.chats.delete(chatId);
     await this.persistAllChats();
     if (chat.persisted.provider === "claude") {
-      const historyFilePath = join9(CLAUDE_HISTORY_DIR, `${chatId}.jsonl`);
+      const historyFilePath = join10(CLAUDE_HISTORY_DIR, `${chatId}.jsonl`);
       await rm(historyFilePath, { force: true });
     }
     await this.publish({
@@ -2636,7 +2795,7 @@ var ChatService = class {
     };
     const provider = persisted.provider === "claude" ? new ClaudeManager({
       workingDirectory: this.workingDirectory,
-      historyFilePath: join9(CLAUDE_HISTORY_DIR, `${persisted.id}.jsonl`),
+      historyFilePath: join10(CLAUDE_HISTORY_DIR, `${persisted.id}.jsonl`),
       initialSessionId: persisted.providerSessionId,
       onSaveSessionId: saveSession,
       onTurnComplete: onProviderTurnComplete,
@@ -2732,7 +2891,7 @@ var ChatService = class {
   }
   async loadChats() {
     try {
-      const content = await readFile5(CHATS_FILE, "utf-8");
+      const content = await readFile6(CHATS_FILE, "utf-8");
       const parsed = JSON.parse(content);
       if (!Array.isArray(parsed)) {
         return [];
@@ -2749,7 +2908,7 @@ var ChatService = class {
     this.writeChain = this.writeChain.catch(() => {
     }).then(async () => {
       const payload = Array.from(this.chats.values()).map((chat) => chat.persisted);
-      await writeFile5(CHATS_FILE, JSON.stringify(payload, null, 2), "utf-8");
+      await writeFile6(CHATS_FILE, JSON.stringify(payload, null, 2), "utf-8");
     });
     await this.writeChain;
   }
@@ -2774,12 +2933,12 @@ import { Hono } from "hono";
 import { z } from "zod";
 
 // 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";
+import { readdir as readdir3, readFile as readFile7 } from "fs/promises";
+import { homedir as homedir10 } from "os";
+import { basename, join as join11 } from "path";
 var PLAN_DIRECTORIES = [
-  join10(homedir9(), ".claude", "plans"),
-  join10(homedir9(), ".replicas", "plans")
+  join11(homedir10(), ".claude", "plans"),
+  join11(homedir10(), ".replicas", "plans")
 ];
 function isMarkdownFile(filename) {
   return filename.toLowerCase().endsWith(".md");
@@ -2813,9 +2972,9 @@ var PlanService = class {
       return null;
     }
     for (const directory of PLAN_DIRECTORIES) {
-      const filePath = join10(directory, safeFilename);
+      const filePath = join11(directory, safeFilename);
       try {
-        const content = await readFile6(filePath, "utf-8");
+        const content = await readFile7(filePath, "utf-8");
         return { filename: safeFilename, content };
       } catch {
       }
@@ -2828,9 +2987,45 @@ var planService = new PlanService();
 // src/services/warm-hooks-service.ts
 import { execFile } from "child_process";
 import { promisify as promisify2 } from "util";
-import { readFile as readFile7 } from "fs/promises";
-import { join as join11 } from "path";
+import { readFile as readFile8 } from "fs/promises";
+import { join as join12 } from "path";
 var execFileAsync = promisify2(execFile);
+async function installSkill(params) {
+  const timeout = clampWarmHookTimeoutMs(params.timeoutMs);
+  try {
+    const { stdout, stderr } = await execFileAsync(
+      "npx",
+      ["skills", "add", params.source, "--all", "--global"],
+      {
+        cwd: params.cwd,
+        timeout,
+        maxBuffer: 1024 * 1024,
+        env: process.env
+      }
+    );
+    const combined = [`$ npx skills add ${params.source} --all --global`, stdout ?? "", stderr ?? ""].filter(Boolean).join("\n");
+    return {
+      exitCode: 0,
+      output: truncateWarmHookOutput(combined),
+      timedOut: false
+    };
+  } catch (error) {
+    const execError = error;
+    const timedOut = execError.signal === "SIGTERM" || execError.killed === true;
+    const exitCode = typeof execError.code === "number" ? execError.code : 1;
+    const combined = [
+      `$ npx skills add ${params.source} --all --global`,
+      execError.stdout ?? "",
+      execError.stderr ?? "",
+      execError.message
+    ].filter(Boolean).join("\n");
+    return {
+      exitCode,
+      output: truncateWarmHookOutput(combined),
+      timedOut
+    };
+  }
+}
 async function executeHookScript(params) {
   const timeout = clampWarmHookTimeoutMs(params.timeoutMs);
   try {
@@ -2859,9 +3054,9 @@ async function executeHookScript(params) {
   }
 }
 async function readRepoWarmHook(repoPath) {
-  const configPath = join11(repoPath, "replicas.json");
+  const configPath = join12(repoPath, "replicas.json");
   try {
-    const raw = await readFile7(configPath, "utf-8");
+    const raw = await readFile8(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!isRecord(parsed) || !("warmHook" in parsed)) {
       return null;
@@ -2895,7 +3090,27 @@ async function collectRepoWarmHooks() {
 }
 async function runWarmHooks(params) {
   const outputBlocks = [];
+  const skills = params.skills ?? [];
   const orgHook = params.organizationWarmHook?.trim();
+  for (const source of skills) {
+    const installResult = await installSkill({
+      source,
+      cwd: gitService.getWorkspaceRoot(),
+      timeoutMs: params.timeoutMs
+    });
+    outputBlocks.push(installResult.output);
+    if (installResult.exitCode === 0) {
+      await environmentDetailsService.track({ skillsInstalled: [source] });
+    }
+    if (installResult.exitCode !== 0) {
+      await environmentDetailsService.setGlobalWarmHook("no", installResult.output);
+      return {
+        exitCode: installResult.exitCode,
+        output: outputBlocks.join("\n\n"),
+        timedOut: installResult.timedOut
+      };
+    }
+  }
   if (orgHook) {
     const orgResult = await executeHookScript({
       label: "org-warm-hook",
@@ -2904,6 +3119,7 @@ async function runWarmHooks(params) {
       timeoutMs: params.timeoutMs
     });
     outputBlocks.push(orgResult.output);
+    await environmentDetailsService.setGlobalWarmHook(orgResult.exitCode === 0 ? "yes" : "no", orgResult.output);
     if (orgResult.exitCode !== 0) {
       return {
         exitCode: orgResult.exitCode,
@@ -2911,9 +3127,18 @@ async function runWarmHooks(params) {
         timedOut: orgResult.timedOut
       };
     }
+  } else {
+    await environmentDetailsService.setGlobalWarmHook("n/a");
   }
   if (params.includeRepoHooks !== false) {
     const repoHooks = await collectRepoWarmHooks();
+    const repoHookNames = new Set(repoHooks.map((repoHook) => repoHook.repoName));
+    const discoveredRepos = await gitService.listRepositories();
+    for (const repo of discoveredRepos) {
+      if (!repoHookNames.has(repo.name)) {
+        await environmentDetailsService.setRepositoryWarmHook(repo.name, "n/a");
+      }
+    }
     for (const repoHook of repoHooks) {
       for (const command of repoHook.commands) {
         const repoResult = await executeHookScript({
@@ -2923,6 +3148,10 @@ async function runWarmHooks(params) {
           timeoutMs: repoHook.timeoutMs
         });
         outputBlocks.push(repoResult.output);
+        await environmentDetailsService.setRepositoryWarmHook(
+          repoHook.repoName,
+          repoResult.exitCode === 0 ? "yes" : "no"
+        );
         if (repoResult.exitCode !== 0) {
           return {
             exitCode: repoResult.exitCode,
@@ -2932,6 +3161,11 @@ async function runWarmHooks(params) {
         }
       }
     }
+  } else {
+    const repos = await gitService.listRepositories();
+    for (const repo of repos) {
+      await environmentDetailsService.setRepositoryWarmHook(repo.name, "n/a");
+    }
   }
   if (outputBlocks.length === 0) {
     return {
@@ -3167,10 +3401,40 @@ function createV1Routes(deps) {
     };
     return c.json(response);
   });
+  app2.get("/version", (c) => {
+    const response = {
+      version: REPLICAS_ENGINE_VERSION
+    };
+    return c.json(response);
+  });
+  app2.get("/environment", async (c) => {
+    try {
+      const details = await environmentDetailsService.getDetails();
+      return c.json(details);
+    } catch (error) {
+      return c.json(
+        jsonError("Failed to load environment details", error instanceof Error ? error.message : "Unknown error"),
+        500
+      );
+    }
+  });
+  app2.post("/environment/track", async (c) => {
+    try {
+      const body = await c.req.json();
+      const details = await environmentDetailsService.track(body);
+      return c.json(details);
+    } catch (error) {
+      return c.json(
+        jsonError("Failed to track environment details", error instanceof Error ? error.message : "Unknown error"),
+        500
+      );
+    }
+  });
   app2.post("/warm-hooks/run", async (c) => {
     try {
       const body = await c.req.json();
       const result = await runWarmHooks({
+        skills: Array.isArray(body.skills) ? body.skills : [],
         organizationWarmHook: body.organizationWarmHook,
         includeRepoHooks: body.includeRepoHooks,
         timeoutMs: body.timeoutMs
@@ -3193,6 +3457,7 @@ function createV1Routes(deps) {
 // src/index.ts
 await engineLogger.initialize();
 await eventService.initialize();
+await environmentDetailsService.initialize();
 var READY_MESSAGE = "========= REPLICAS WORKSPACE READY ==========";
 var COMPLETION_MESSAGE = "========= REPLICAS WORKSPACE INITIALIZATION COMPLETE ==========";
 function checkActiveSSHSessions() {
@@ -3227,7 +3492,7 @@ app.get("/health", async (c) => {
     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 readFile9("/var/log/cloud-init-output.log", "utf-8");
     let status;
     if (logContent.includes(COMPLETION_MESSAGE)) {
       status = "active";

package/package.json

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