@songsid/agend 2.1.1 → 2.1.2-beta.10

package/dist/fleet-manager.js

@@ -163,6 +163,10 @@ export class FleetManager {
     failoverActive = new Map(); // instance → current failover model
     // IPC reconnect: tracks instances being intentionally stopped (skip reconnect)
     ipcStoppingInstances = new Set();
+    /** Coalesce concurrent connection attempts for the same daemon socket. */
+    ipcConnectInFlight = new Map();
+    /** At most one reconnect/backoff loop may exist per instance. */
+    ipcReconnectInFlight = new Map();
     // Adapter restart: prevents re-entrant restart attempts
     adapterRestarting = new Set();
     // Adapter isolation: track state per adapter for retry + visibility
@@ -651,7 +655,7 @@ export class FleetManager {
         await new Promise(resolve => setTimeout(resolve, 250));
         await this.startClassicInstance(instanceName, this.classicChannels.getBackendByInstance(instanceName, this.fleetConfig?.defaults?.backend), this.classicChannels.getPreTaskCommand(channel.channelId, channel.adapterId), this.classicChannels.getModel(channel.channelId, channel.adapterId, this.fleetConfig?.defaults?.model), this.classicChannels.getAutoPauseAfter(channel.channelId, channel.adapterId, this.fleetConfig?.defaults?.auto_pause_after));
     }
-    async startInstance(name, config, topicMode) {
+    async startInstance(name, config, topicMode, kind = "fleet-topic") {
         if (this.lifecycle.isPaused(name)) {
             this.logger.info({ name }, "Persisted paused instance — skipping startup");
             return;
@@ -667,7 +671,11 @@ export class FleetManager {
             this.ensureGeneralInstructions(config.working_directory, config.backend);
         }
         this.instanceProcessStatus.delete(name);
-        await this.lifecycle.start(name, config, topicMode);
+        await this.lifecycle.start(name, config, topicMode, {
+            kind,
+            backend: config.backend ?? this.fleetConfig?.defaults?.backend ?? "claude-code",
+            model: this.resolveInstanceModel(name).display,
+        });
         // Auto-connect IPC — daemon.start() ensures socket is ready before resolving
         await this.connectIpcToInstance(name);
     }
@@ -978,6 +986,11 @@ export class FleetManager {
             // Rotate fleet.log daily too (besides the startup size check above), so a
             // long-running fleet doesn't accumulate an unbounded log.
             rotateLogIfNeeded(join(this.dataDir, "fleet.log"));
+            // Instance output.log is pipe-pane (TUI ANSI). Daemon health ticks also
+            // rotate it; this is the daily safety net for idle/stopped instances.
+            for (const name of Object.keys(this.fleetConfig?.instances ?? {})) {
+                rotateLogIfNeeded(join(this.dataDir, "instances", name, "output.log"));
+            }
         }, () => {
             const instances = Object.keys(this.fleetConfig?.instances ?? {});
             const costMap = new Map();
@@ -1931,19 +1944,38 @@ export class FleetManager {
         this.logger.info({ adapterId, type: channelConfig.type }, "Additional adapter started");
     }
     /** Connect IPC to a single instance with all handlers */
-    async connectIpcToInstance(name) {
+    connectIpcToInstance(name) {
+        const inFlight = this.ipcConnectInFlight.get(name);
+        if (inFlight)
+            return inFlight;
+        const connection = this.connectIpcToInstanceInternal(name)
+            .finally(() => {
+            if (this.ipcConnectInFlight.get(name) === connection) {
+                this.ipcConnectInFlight.delete(name);
+            }
+        });
+        this.ipcConnectInFlight.set(name, connection);
+        return connection;
+    }
+    async connectIpcToInstanceInternal(name) {
         // Close existing client to prevent socket leak on reconnect
         const existing = this.instanceIpcClients.get(name);
         if (existing) {
-            this.ipcStoppingInstances.add(name);
+            // Remove application listeners before destroying the socket. Even if a
+            // future regression creates two clients, the replaced one cannot keep
+            // handling fleet_outbound messages as an orphan.
+            existing.removeAllListeners();
             try {
-                existing.close();
+                await existing.close();
             }
             catch (err) {
                 this.logger.debug({ err, name }, "IPC client close failed (likely already closed)");
             }
-            this.instanceIpcClients.delete(name);
-            this.ipcStoppingInstances.delete(name);
+            finally {
+                if (this.instanceIpcClients.get(name) === existing) {
+                    this.instanceIpcClients.delete(name);
+                }
+            }
         }
         const sockPath = join(this.getInstanceDir(name), "channel.sock");
         if (!existsSync(sockPath))
@@ -2021,6 +2053,10 @@ export class FleetManager {
             }
             // Auto-reconnect on disconnect (unless intentionally stopping)
             ipc.on("disconnect", () => {
+                // A delayed event from a replaced/stale client must never delete the
+                // current connection or start another reconnect loop.
+                if (this.instanceIpcClients.get(name) !== ipc)
+                    return;
                 this.instanceIpcClients.delete(name);
                 if (this.ipcStoppingInstances.has(name))
                     return;
@@ -2032,7 +2068,20 @@ export class FleetManager {
         }
     }
     /** Attempt IPC reconnection with exponential backoff */
-    async ipcReconnect(name) {
+    ipcReconnect(name) {
+        const inFlight = this.ipcReconnectInFlight.get(name);
+        if (inFlight)
+            return inFlight;
+        const reconnect = this.runIpcReconnect(name)
+            .finally(() => {
+            if (this.ipcReconnectInFlight.get(name) === reconnect) {
+                this.ipcReconnectInFlight.delete(name);
+            }
+        });
+        this.ipcReconnectInFlight.set(name, reconnect);
+        return reconnect;
+    }
+    async runIpcReconnect(name) {
         for (let attempt = 1;; attempt++) {
             if (this.ipcStoppingInstances.has(name) || !this.daemons.has(name))
                 return;
@@ -4771,7 +4820,7 @@ When users create specialized instances, suggest these configurations:
             ...(preTaskCommand ? { pre_task_command: preTaskCommand } : {}),
         };
         const topicMode = this.fleetConfig?.channel?.mode === "topic";
-        await this.startInstance(instanceName, config, topicMode);
+        await this.startInstance(instanceName, config, topicMode, "classic");
     }
     /** Handle /start slash command — register classic channel */
     async handleClassicStart(channelId, channelName, userId, guildId, adapterId, backend) {