@songsid/agend 2.1.2-beta.42 → 2.1.2-beta.44

package/dist/fleet-manager.js

@@ -50,6 +50,7 @@ import { validateFleetConfig } from "./config-validator.js";
 import { readLastInboundAt } from "./daemon.js";
 import { clearPausedMarker } from "./pause-marker.js";
 import { releaseProcessFleetLock } from "./fleet-lock.js";
+import { GENERAL_PAUSE_ERROR, isGeneralInstance } from "./general-instance.js";
 import { getTmuxSession } from "./config.js";
 export function resolveReplyThreadId(argsThreadId, instanceConfig) {
     if (typeof argsThreadId === "string" && argsThreadId.length > 0) {
@@ -587,7 +588,25 @@ export class FleetManager {
     getInstanceStatus(name) {
         if (this.lifecycle.isPaused(name))
             return "paused";
+        const daemon = this.lifecycle.daemons.get(name);
         const processStatus = this.instanceProcessStatus.get(name);
+        // IPC can be disconnected during a respawn, so the event which announces
+        // the new live pane may be missed.  The in-process daemon is authoritative
+        // in that case; do not leave a stale `crashed` cache masking an instance
+        // that has already recovered and can answer messages.
+        const daemonStatus = daemon?.getProcessStatus?.();
+        if (daemonStatus === "running") {
+            if (processStatus)
+                this.instanceProcessStatus.delete(name);
+            // A recovered in-process daemon is also the authority for clearing a
+            // marker left by a crash-loop/reconnect race.  This keeps standalone
+            // `agend ls` from seeing the old marker after the next API outage.
+            try {
+                unlinkSync(join(this.getInstanceDir(name), "crash-state.json"));
+            }
+            catch { /* absent */ }
+            return "running";
+        }
         if (processStatus)
             return processStatus;
         const pidPath = join(this.getInstanceDir(name), "daemon.pid");
@@ -669,6 +688,13 @@ export class FleetManager {
     cacheInstanceProcessStatus(name, status) {
         if (status === "running") {
             this.instanceProcessStatus.delete(name);
+            // A prior crash-loop marker is one-shot.  Successful respawn is the
+            // authoritative recovery signal even when the marker outlived an IPC
+            // disconnect and was not consumed by a new Daemon constructor.
+            try {
+                unlinkSync(join(this.getInstanceDir(name), "crash-state.json"));
+            }
+            catch { /* absent */ }
             return;
         }
         if (status !== "crashed" && status !== "stopped")
@@ -704,7 +730,7 @@ export class FleetManager {
         const victims = selectLruEvictions(warm, cap, {
             exclude,
             isEvicting: name => this.warmCapEvicting.has(name),
-            isGeneral: name => this.fleetConfig?.instances[name]?.general_topic === true,
+            isGeneral: name => isGeneralInstance(this.fleetConfig, name),
             isIdle: name => this.getInstanceExecutionState(name) === "idle",
             lastInboundAt: name => readLastInboundAt(this.getInstanceDir(name)) ?? 0,
         });
@@ -878,6 +904,9 @@ export class FleetManager {
             this.enforceWarmCap(name); // manual wake still respects the fleet warm cap
             return "awake";
         }
+        if (isGeneralInstance(this.fleetConfig, name)) {
+            throw new Error(GENERAL_PAUSE_ERROR);
+        }
         await this.lifecycle.pause(name);
         return this.lifecycle.isPaused(name) ? "paused" : "not_idle";
     }
@@ -897,11 +926,41 @@ 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, kind = "fleet-topic") {
+    async startInstance(name, config, topicMode, kind = "fleet-topic", 
+    /**
+     * Explicit starts (CLI/API) may resume a paused or failed daemon.  Startup
+     * and reconcile calls leave this false so a persisted pause remains paused
+     * across a fleet restart.
+     */
+    resumePaused = false) {
+        if (resumePaused && this.lifecycle.isPaused(name)) {
+            await this.lifecycle.wake(name, 30_000);
+            // A successful wake clears the persisted pause marker and produces a
+            // fresh instance_state snapshot.  Drop any stale process error left by a
+            // pre-pause crash so /api/fleet and `agend ls` converge on running.
+            this.instanceProcessStatus.delete(name);
+            return;
+        }
         if (this.lifecycle.isPaused(name)) {
             this.logger.info({ name }, "Persisted paused instance — skipping startup");
             return;
         }
+        if (this.lifecycle.daemons.has(name)) {
+            // A crash-loop daemon remains in the lifecycle map so its health monitor
+            // can expose the failure.  The old start path treated that object as
+            // already running and merely deleted the process-status cache, leaving a
+            // dead pane (and crash marker) behind.  An explicit start is a recovery
+            // request: tear down the failed daemon and build a fresh one.
+            if (resumePaused) {
+                const status = this.getInstanceStatus(name);
+                if (status === "crashed" || status === "stopped") {
+                    await this.restartSingleInstance(name);
+                    return;
+                }
+            }
+            this.logger.info({ name }, "Instance already running, skipping");
+            return;
+        }
         if (config.general_topic) {
             // antigravity (agy) does not read MCP instructions — fleet context and
             // routing instructions are not injected, so it cannot act as a dispatcher.
@@ -912,12 +971,19 @@ export class FleetManager {
             }
             this.ensureGeneralInstructions(config.working_directory, config.backend);
         }
-        this.instanceProcessStatus.delete(name);
         await this.lifecycle.start(name, config, topicMode, {
             kind,
             backend: config.backend ?? this.fleetConfig?.defaults?.backend ?? "claude-code",
             model: this.resolveInstanceModel(name).display,
         });
+        // Only clear a stale process status after a real start succeeded.  Clearing
+        // it before lifecycle.start() can turn a crash-loop daemon's dead pane into
+        // a falsely running instance when lifecycle.start() returns early.
+        this.instanceProcessStatus.delete(name);
+        try {
+            unlinkSync(join(this.getInstanceDir(name), "crash-state.json"));
+        }
+        catch { /* consumed or absent */ }
         // Auto-connect IPC — daemon.start() ensures socket is ready before resolving
         await this.connectIpcToInstance(name);
     }
@@ -6858,7 +6924,7 @@ When users create specialized instances, suggest these configurations:
                 (async () => {
                     try {
                         const topicMode = this.fleetConfig?.channel?.mode === "topic";
-                        await this.startInstance(name, config, topicMode ?? false);
+                        await this.startInstance(name, config, topicMode ?? false, "fleet-topic", true);
                         this.emitSseEvent("status", this.getUiStatus());
                         res.writeHead(200);
                         res.end(JSON.stringify({ ok: true }));