@songsid/agend 2.1.8-beta.1 → 2.1.8-beta.3

package/dist/daemon.js

@@ -906,6 +906,11 @@ export class BlockingProcessDetector {
         this.notified = false;
     }
 }
+/** Response types the fleet sends back for tool calls the daemon forwarded. */
+const FLEET_RESPONSE_TYPES = new Set([
+    "fleet_schedule_response", "fleet_outbound_response", "fleet_decision_response", "fleet_task_response",
+    "fleet_display_name_response", "fleet_description_response", "fleet_persona_emoji_response",
+]);
 export class Daemon extends EventEmitter {
     name;
     config;
@@ -1506,21 +1511,7 @@ export class Daemon extends EventEmitter {
         await this.ipcServer.listen();
         ipcListening = true;
         // Permanent IPC dispatcher: routes responses to pending requests by type+id key
-        this.ipcServer.on("message", (msg) => {
-            const type = msg.type;
-            if (!type)
-                return;
-            // Build lookup key matching the pattern used when registering
-            let key;
-            if ((type === "fleet_schedule_response" || type === "fleet_outbound_response" || type === "fleet_decision_response" || type === "fleet_task_response" || type === "fleet_display_name_response" || type === "fleet_description_response") && msg.fleetRequestId) {
-                key = String(msg.fleetRequestId);
-            }
-            if (key && this.pendingIpcRequests.has(key)) {
-                const handler = this.pendingIpcRequests.get(key);
-                this.pendingIpcRequests.delete(key);
-                handler(msg);
-            }
-        });
+        this.ipcServer.on("message", (msg) => this.routeFleetResponse(msg));
         // IPC message relay: when daemon wants to push a channel message to Claude,
         // it broadcasts to all IPC clients (the MCP server is one of them).
         // When MCP server sends a tool_call, daemon handles it via the messageBus.
@@ -5045,10 +5036,13 @@ export class Daemon extends EventEmitter {
             // The pane text comes back with the verdict: a transient that is still
             // repainting is still working, and that is the only thing separating a
             // slow resume from a wedged one.
+            if (transient)
+                this.resetFooterFallback();
             return transient ? { state: "active", transient, pane } : { state: "clear" };
         }
         catch (err) {
             this.logger.debug({ err }, "capture-pane failed during the input-transient probe — pane state unknown");
+            this.resetFooterFallback();
             return { state: "unknown" };
         }
     }
@@ -5259,13 +5253,77 @@ export class Daemon extends EventEmitter {
             return !check;
         try {
             const mode = await this.tmux.getPaneInputMode?.();
-            if (mode !== "raw")
+            if (mode !== "raw") {
+                this.resetFooterFallback();
                 return false;
-            return check.call(this.backend, await this.tmux.capturePane());
+            }
+            return this.deliveryInputReadyPane(await this.tmux.capturePane());
         }
         catch {
+            this.resetFooterFallback();
+            return false;
+        }
+    }
+    /** Pane text of the current footer-fallback candidate, and since when it has been unchanged. */
+    footerFallbackPaneKey = null;
+    footerFallbackStableSince = 0;
+    /** The launch the candidate was seen in: a new spawn or launch attempt starts over. */
+    footerFallbackEpoch = null;
+    /**
+     * Forget the footer-fallback candidate. Called whenever the pane is seen
+     * outside the candidate state (busy, a dialog, a transient, unreadable) and
+     * on every spawn: "stable for UNKNOWN_LAYOUT_STABLE_MS" must mean this screen,
+     * continuously, not time accumulated across an interruption.
+     */
+    resetFooterFallback() {
+        this.footerFallbackPaneKey = null;
+        this.footerFallbackEpoch = null;
+    }
+    footerFallbackWarnedGeneration = null;
+    /**
+     * The input-row proof used before a paste (#931/#947), with one fallback
+     * (#1031). Codex sometimes paints an idle composer without its Context
+     * status item even though tui.status_line asks for it: after four fleet
+     * restarts, sol's resumed session showed only `⚠ 2 warnings · f2 to view`.
+     * The proof needs a recognised footer, so the first delivery after each
+     * restart waited 30 minutes, failed, and waited again, for seven hours.
+     *
+     * When the footer is the only thing missing, the #978 structural evidence
+     * stands in for it, all of it required: the backend's own stable-unknown
+     * idle check (an empty live composer; no busy row, esc-to-interrupt row,
+     * queued ↳ input or known picker), no input transient such as the resume
+     * load, and the same screen for UNKNOWN_LAYOUT_STABLE_MS. The raw-tty
+     * requirement stays with the caller.
+     */
+    deliveryInputReadyPane(pane) {
+        const check = this.backend?.isDeliveryInputReadyPane;
+        if (!check)
+            return true;
+        if (check.call(this.backend, pane)) {
+            this.footerFallbackPaneKey = null;
+            return true;
+        }
+        const stableUnknown = this.backend?.isStableUnknownLayoutIdlePane;
+        if (!stableUnknown?.call(this.backend, pane) || this.inputTransientInPane(pane)) {
+            this.footerFallbackPaneKey = null;
+            return false;
+        }
+        const key = pane.replace(/⋆/gu, "").replace(/[ \t]+$/gmu, "");
+        const epoch = `${this.spawnGeneration}:${this.launchAttempt}`;
+        const now = Date.now();
+        if (key !== this.footerFallbackPaneKey || epoch !== this.footerFallbackEpoch) {
+            this.footerFallbackPaneKey = key;
+            this.footerFallbackEpoch = epoch;
+            this.footerFallbackStableSince = now;
+            return false;
+        }
+        if (now - this.footerFallbackStableSince < UNKNOWN_LAYOUT_STABLE_MS)
             return false;
+        if (this.footerFallbackWarnedGeneration !== this.spawnGeneration) {
+            this.footerFallbackWarnedGeneration = this.spawnGeneration;
+            this.logger.warn({ backend: this.backend?.binaryName, stableForMs: now - this.footerFallbackStableSince }, "Idle footer not recognised — delivering on the #978 fallback (stable empty composer, no busy/queued/dialog, raw tty, no transient)");
         }
+        return true;
     }
     /**
      * Why a pane is not deliverable matters. "busy" may be handed to a native
@@ -5275,16 +5333,26 @@ export class Daemon extends EventEmitter {
      * pane proves nothing. The silence gate comes first and costs no capture.
      */
     async paneReadinessForDelivery(windowId) {
-        if (!this.isPaneIdleForDelivery(windowId))
+        // Each early return below is the pane seen outside the footer-fallback
+        // candidate state, and never reaches deliveryInputReadyPane: reset here.
+        if (!this.isPaneIdleForDelivery(windowId)) {
+            this.resetFooterFallback();
             return "busy";
+        }
         const probe = await this.probeBlockingDialog();
-        if (probe.state !== "clear")
+        if (probe.state !== "clear") {
+            this.resetFooterFallback();
             return probe.state;
+        }
         const transient = await this.probeInputTransient();
-        if (transient.state === "active")
+        if (transient.state === "active") {
+            this.resetFooterFallback();
             return "transient";
-        if (transient.state === "unknown")
+        }
+        if (transient.state === "unknown") {
+            this.resetFooterFallback();
             return "unknown";
+        }
         if (this.needsStartupInputProof()) {
             return await this.hasPositiveDeliveryInput() ? "ready" : "transient";
         }
@@ -5461,7 +5529,7 @@ export class Daemon extends EventEmitter {
             return "busy";
         if (this.backend?.getBusyPattern?.()?.test(pane))
             return "busy";
-        if (this.backend?.isDeliveryInputReadyPane && !this.backend.isDeliveryInputReadyPane(pane))
+        if (!this.deliveryInputReadyPane(pane))
             return "busy";
         if (strandedAgendMessageInInput(pane, prompt))
             return "stranded";
@@ -6501,6 +6569,18 @@ export class Daemon extends EventEmitter {
         }
         return undefined;
     }
+    /** The fleet's answers to forwarded tool calls: settle the pending request they name. */
+    routeFleetResponse(msg) {
+        const type = msg.type;
+        if (!type || !FLEET_RESPONSE_TYPES.has(type) || !msg.fleetRequestId)
+            return;
+        const key = String(msg.fleetRequestId);
+        const handler = this.pendingIpcRequests.get(key);
+        if (!handler)
+            return;
+        this.pendingIpcRequests.delete(key);
+        handler(msg);
+    }
     /**
      * Handle a tool call from the MCP server (forwarded by Claude).
      * Routes to the channel adapter via MessageBus.
@@ -6549,9 +6629,11 @@ export class Daemon extends EventEmitter {
             this.handleReleaseRepo(args, respond);
             return;
         }
-        if (tool === "set_display_name" || tool === "set_description") {
-            const type = tool === "set_display_name" ? "fleet_set_display_name" : "fleet_set_description";
-            const fleetReqId = `${tool === "set_display_name" ? "dn" : "desc"}_${++this.fleetRequestSeq}_${requestId}`;
+        if (tool === "set_display_name" || tool === "set_description" || tool === "list_emojis" || tool === "set_persona_emoji") {
+            const type = tool === "set_display_name" ? "fleet_set_display_name"
+                : tool === "set_description" ? "fleet_set_description"
+                    : tool === "list_emojis" ? "fleet_list_emojis" : "fleet_set_persona_emoji";
+            const fleetReqId = `${tool === "set_display_name" ? "dn" : tool === "set_description" ? "desc" : "emoji"}_${++this.fleetRequestSeq}_${requestId}`;
             const timeout = setTimeout(() => {
                 this.pendingIpcRequests.delete(fleetReqId);
                 respond(null, `${tool} timed out`);