@episoda/cli 0.2.174 → 0.2.175

package/dist/daemon/daemon-process.js

@@ -2996,7 +2996,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@episoda/cli",
-      version: "0.2.174",
+      version: "0.2.175",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -7630,26 +7630,12 @@ var AgentControlPlane = class {
     const existingSession = this.sessions.get(sessionId);
     if (existingSession) {
       if (existingSession.provider === provider && existingSession.moduleId === moduleId) {
-        console.log(`[AgentManager] EP1232: Session ${sessionId} already exists, treating start as message (idempotent)`);
+        console.log(`[AgentManager] EP1417: Session ${sessionId} already exists, acknowledging duplicate start`);
         if (requestedWorkspaceId && !normalizeWorkspaceId(existingSession.workspaceId)) {
           existingSession.workspaceId = requestedWorkspaceId;
           console.log(`[AgentManager] EP1357: Updated session ${sessionId} workspaceId from start options`);
         }
-        return this.sendMessage({
-          sessionId,
-          message,
-          isFirstMessage: false,
-          // Not first since session exists
-          canWrite,
-          readOnlyReason,
-          onChunk,
-          onToolUse,
-          // EP1236: Pass tool use callback
-          onToolResult,
-          // EP1311: Pass tool result callback
-          onComplete,
-          onError
-        });
+        return { success: true };
       }
       console.log(`[AgentManager] EP1232: Session ${sessionId} exists with incompatible config - provider: ${existingSession.provider} vs ${provider}, module: ${existingSession.moduleId} vs ${moduleId}`);
       return { success: false, error: "Session already exists with incompatible configuration" };
@@ -13609,6 +13595,8 @@ var HealthOrchestrator = class _HealthOrchestrator {
     this.tunnelPollInterval = null;
     // EP833: Track consecutive health check failures per tunnel
     this.tunnelHealthFailures = /* @__PURE__ */ new Map();
+    // Restart after 2 consecutive failures
+    this.tunnelRestartCooldownUntil = /* @__PURE__ */ new Map();
     // 3 second timeout for health checks
     // EP929: Health check polling interval (restored from EP843 removal)
     // Health checks are orthogonal to push-based state sync - they detect dead tunnels
@@ -13623,7 +13611,11 @@ var HealthOrchestrator = class _HealthOrchestrator {
     this.HEALTH_CHECK_FAILURE_THRESHOLD = 2;
   }
   static {
-    // Restart after 2 consecutive failures
+    // moduleUid -> unix ms
+    this.HEALTH_RESTART_COOLDOWN_MS = 3 * 60 * 1e3;
+  }
+  static {
+    // 3 minutes
     this.HEALTH_CHECK_TIMEOUT_MS = 3e3;
   }
   static {
@@ -14043,20 +14035,55 @@ var HealthOrchestrator = class _HealthOrchestrator {
       const isHealthy = await this.checkTunnelHealth(tunnel);
       if (isHealthy) {
         this.tunnelHealthFailures.delete(tunnel.moduleUid);
+        this.tunnelRestartCooldownUntil.delete(tunnel.moduleUid);
       } else {
         const failures = (this.tunnelHealthFailures.get(tunnel.moduleUid) || 0) + 1;
         this.tunnelHealthFailures.set(tunnel.moduleUid, failures);
         console.log(`[Daemon] EP833: Health check failed for ${tunnel.moduleUid} (${failures}/${_HealthOrchestrator.HEALTH_CHECK_FAILURE_THRESHOLD})`);
-        if (failures >= _HealthOrchestrator.HEALTH_CHECK_FAILURE_THRESHOLD) {
-          console.log(`[Daemon] EP833: Tunnel unhealthy for ${tunnel.moduleUid}, restarting...`);
-          await this.host.withTunnelLock(tunnel.moduleUid, async () => {
-            await this.restartTunnel(tunnel.moduleUid, tunnel.port);
-          });
-          this.tunnelHealthFailures.delete(tunnel.moduleUid);
+        if (failures < _HealthOrchestrator.HEALTH_CHECK_FAILURE_THRESHOLD) {
+          continue;
         }
+        const now = Date.now();
+        const cooldownUntil = this.tunnelRestartCooldownUntil.get(tunnel.moduleUid) || 0;
+        if (cooldownUntil > now) {
+          continue;
+        }
+        const healthProjectId = config.project_id || config.projectId;
+        if (healthProjectId) {
+          const activeModuleUids = await this.fetchActiveModuleUids(healthProjectId);
+          if (activeModuleUids && !activeModuleUids.includes(tunnel.moduleUid)) {
+            console.log(`[Daemon] EP1417: Skipping health auto-restart for ${tunnel.moduleUid}; module is no longer active`);
+            await this.retireInactiveTunnel(tunnel.moduleUid);
+            this.tunnelHealthFailures.delete(tunnel.moduleUid);
+            this.tunnelRestartCooldownUntil.delete(tunnel.moduleUid);
+            continue;
+          }
+        }
+        console.log(`[Daemon] EP833: Tunnel unhealthy for ${tunnel.moduleUid}, restarting...`);
+        await this.host.withTunnelLock(tunnel.moduleUid, async () => {
+          await this.restartTunnel(tunnel.moduleUid, tunnel.port);
+        });
+        this.tunnelHealthFailures.delete(tunnel.moduleUid);
+        this.tunnelRestartCooldownUntil.set(
+          tunnel.moduleUid,
+          now + _HealthOrchestrator.HEALTH_RESTART_COOLDOWN_MS
+        );
       }
     }
   }
+  async retireInactiveTunnel(moduleUid) {
+    try {
+      const tunnelManager = getTunnelManager();
+      await tunnelManager.stopTunnel(moduleUid);
+    } catch (error) {
+      console.warn(`[Daemon] EP1417: Failed to stop inactive tunnel for ${moduleUid}:`, error);
+    }
+    try {
+      await stopDevServer(moduleUid);
+    } catch (error) {
+      console.warn(`[Daemon] EP1417: Failed to stop inactive dev server for ${moduleUid}:`, error);
+    }
+  }
   /**
    * EP833: Check if a tunnel is healthy
    * EP1042: Now also verifies dev server ownership (correct worktree)