@songsid/agend 2.1.2-beta.1 → 2.1.2-beta.11

package/dist/daemon.js

@@ -3,6 +3,7 @@ import { mkdirSync, writeFileSync, readFileSync, existsSync, unlinkSync, rmSync,
 import { fileURLToPath } from "node:url";
 import { createHash, randomBytes } from "node:crypto";
 import { EventEmitter } from "node:events";
+import { rotateLogIfNeeded } from "./logger.js";
 import { clearPausedMarker, writePausedMarker } from "./pause-marker.js";
 import { TmuxManager, resolveTmuxLogicalSize } from "./tmux-manager.js";
 import { TranscriptMonitor } from "./transcript-monitor.js";
@@ -193,6 +194,8 @@ export class PendingWorkTracker {
 const NORMAL_ENTER_SETTLE_MS = 500;
 const FIRST_ENTER_SETTLE_MS = 1_750;
 const FIRST_DELIVERY_WINDOW_MS = 5_000;
+/** After busy native-queue paste+Enter, wait before checking the pane for silent loss. */
+const NATIVE_QUEUE_PASTE_VERIFY_MS = 2_000;
 /**
  * One-shot timing gate for the first paste after a CLI reaches its ready
  * prompt. Recent tmux versions expose a short interval where the prompt is
@@ -244,6 +247,7 @@ export class Daemon extends EventEmitter {
     topicMode;
     backend;
     controlClient;
+    runtimeIdentity;
     logger;
     tmuxSessionName;
     tmux = null;
@@ -371,7 +375,7 @@ export class Daemon extends EventEmitter {
         this.errorRecoveryDeadlineAt = 0;
         this.activeErrorPatternKey = null;
     }
-    constructor(name, config, instanceDir, topicMode = false, backend, controlClient, rootLogger) {
+    constructor(name, config, instanceDir, topicMode = false, backend, controlClient, rootLogger, runtimeIdentity) {
         super();
         this.name = name;
         this.config = config;
@@ -379,8 +383,14 @@ export class Daemon extends EventEmitter {
         this.topicMode = topicMode;
         this.backend = backend;
         this.controlClient = controlClient;
+        this.runtimeIdentity = runtimeIdentity;
         if (!rootLogger)
             throw new Error("Daemon requires a shared root logger");
+        this.runtimeIdentity ??= {
+            kind: "fleet-topic",
+            backend: config.backend ?? backend?.binaryName ?? "unknown",
+            model: config.model ?? "default",
+        };
         this.logger = rootLogger.child({ instance: name }, { level: config.log_level });
         this.tmuxSessionName = getTmuxSession();
         this.messageBus = new MessageBus();
@@ -612,8 +622,12 @@ export class Daemon extends EventEmitter {
             catch { /* non-fatal */ }
         })();
         if (!this.config.lightweight) {
-            // 3. Pipe-pane for prompt detection
+            // 3. Pipe-pane for prompt detection. Rotate first so a ballooned log from a
+            // previous stuck splash (hundreds of MB of ANSI frames) is truncated before
+            // we attach — pipe-pane uses `cat >>` on the same inode, so copytruncate
+            // keeps the writer attached after size resets.
             const outputLog = join(this.instanceDir, "output.log");
+            rotateLogIfNeeded(outputLog);
             await this.tmux.pipeOutput(outputLog).catch(() => { });
             // 4. Transcript monitor
             this.transcriptMonitor = new TranscriptMonitor(this.instanceDir, this.logger);
@@ -716,6 +730,11 @@ export class Daemon extends EventEmitter {
                     return;
                 }
                 if (paneStatus?.alive) {
+                    // Instance output.log is fed by tmux pipe-pane and was previously never
+                    // rotated (only fleet.log / daemon.log were). Cap growth every tick.
+                    if (!this.config.lightweight) {
+                        rotateLogIfNeeded(join(this.instanceDir, "output.log"));
+                    }
                     scheduleNext();
                     return;
                 }
@@ -1755,18 +1774,19 @@ export class Daemon extends EventEmitter {
     }
     /**
      * Deliver a single message and drive its status reactions:
-     *   ⏳ message_queued    — CLI busy; queued, waiting for idle
+     *   ⏳ message_queued    — CLI busy; queued locally or by the backend
      *   👀 message_delivered — pasted + Enter sent; agent now has it
-     *   ✅ message_confirmed — idle→busy transition observed; agent is processing
+     *   ✅ message_confirmed — processing observed, or native queue handoff succeeded
      *   ❌ message_failed    — tmux window gone, paste retries exhausted
      * Returns true once the message is in the CLI, false only on real delivery failure.
      *
      * Bug A (silent message loss): paste failures retry with backoff (window recovery)
      * and emit `message_failed` if all attempts fail.
-     * Busy handling (UX): we never force-paste into a busy CLI and never give up on a
-     * busy one — we show ⏳ and wait for idle indefinitely (a genuinely hung CLI is the
-     * hang detector's job; a user who can't wait presses Cancel → Escape → idle). The
-     * pasteLock is serial, so later messages naturally queue behind this wait.
+     * Busy handling (UX): backends without a native input queue show ⏳ and wait for
+     * idle indefinitely (a genuinely hung CLI is the hang detector's job). Backends
+     * that explicitly support queued input receive one complete paste+Enter transaction
+     * immediately and own the application-level queue themselves. The pasteLock remains
+     * serial in both cases so separate PTY writes can never overlap.
      */
     async deliverMessage(formatted, status) {
         // Sanitize unclosed code fences — they cause CLI to wait for closure on Enter
@@ -1776,12 +1796,22 @@ export class Daemon extends EventEmitter {
             formatted = formatted.replace(/```/g, "");
         }
         let windowId = this.getWindowId();
-        // If the CLI is busy, show ⏳ and wait for it to go idle — no timeout, no force.
+        const supportsQueuedInput = this.backend?.supportsQueuedInput?.() === true;
+        let handingOffToNativeQueue = false;
+        // If the CLI is busy, either hand the complete submission to its native input
+        // queue or wait for idle. Native queue support is an explicit backend capability:
+        // normal Enter input has steering/interrupt semantics in several other CLIs.
         if (windowId && this.controlClient && !this.controlClient.isIdle(windowId)) {
             if (status)
                 this.emit("message_queued", status);
-            this.logger.debug("CLI busy — queuing message until idle");
-            await this.controlClient.waitUntilIdle(windowId);
+            if (supportsQueuedInput) {
+                handingOffToNativeQueue = true;
+                this.logger.debug("CLI busy — handing message to backend-native input queue");
+            }
+            else {
+                this.logger.debug("CLI busy — queuing message until idle");
+                await this.controlClient.waitUntilIdle(windowId);
+            }
         }
         // Bug A: paste with backoff. Transient failures are usually a stale window id
         // after a crash/respawn — recover by name and retry (max 3 attempts, 2s apart).
@@ -1807,9 +1837,56 @@ export class Daemon extends EventEmitter {
             await this.tmux.sendSpecialKey("Enter");
             if (status)
                 this.emit("message_delivered", status); // 👀
-            // Confirm the CLI accepted the message by transitioning idle→busy (new output
-            // after Enter). If still idle after ~2s the Enter was likely swallowed while
-            // the TUI was redrawing — re-send Enter once and re-check.
+            // Busy queue-capable CLIs (codex) may accept paste without an idle→busy
+            // transition. Do NOT probe for busy — a second bare Enter can mutate the
+            // queue. Instead verify the paste actually landed in the pane (TUI redraw
+            // can silently swallow it). Idle submissions keep the swallowed-Enter path.
+            if (handingOffToNativeQueue) {
+                await new Promise(r => setTimeout(r, NATIVE_QUEUE_PASTE_VERIFY_MS));
+                if (await this.nativeQueuePasteVisible(formatted)) {
+                    if (status)
+                        this.emit("message_confirmed", status); // ✅ native queue accepted
+                    return true;
+                }
+                // Silent loss: fall back once to the normal idle-gated path.
+                this.logger.warn("Native-queue paste not visible in pane — retrying via idle-gated delivery");
+                if (windowId && this.controlClient) {
+                    await this.controlClient.waitUntilIdle(windowId);
+                }
+                const repasted = await this.tmux.pasteBuffer(formatted);
+                if (!repasted) {
+                    this.logger.error("Idle-gated redelivery paste failed after native-queue silent loss");
+                    if (status)
+                        this.emit("message_failed", status); // ❌
+                    return false;
+                }
+                await new Promise(r => setTimeout(r, NORMAL_ENTER_SETTLE_MS));
+                const retryAt = Date.now();
+                await this.tmux.sendSpecialKey("Enter");
+                if (windowId && this.controlClient) {
+                    let becameBusy = await this.confirmBusyAfterEnter(windowId, retryAt);
+                    if (!becameBusy) {
+                        this.logger.warn("No idle→busy after idle-gated redelivery — re-sending Enter once");
+                        const retry2At = Date.now();
+                        await this.tmux.sendSpecialKey("Enter");
+                        becameBusy = await this.confirmBusyAfterEnter(windowId, retry2At);
+                    }
+                    if (becameBusy) {
+                        if (status)
+                            this.emit("message_confirmed", status); // ✅
+                        return true;
+                    }
+                }
+                else if (await this.nativeQueuePasteVisible(formatted)) {
+                    if (status)
+                        this.emit("message_confirmed", status); // ✅
+                    return true;
+                }
+                this.logger.error("Idle-gated redelivery also failed after native-queue silent loss");
+                if (status)
+                    this.emit("message_failed", status); // ❌
+                return false;
+            }
             if (windowId && this.controlClient) {
                 let becameBusy = await this.confirmBusyAfterEnter(windowId, enterAt);
                 if (!becameBusy) {
@@ -1835,6 +1912,33 @@ export class Daemon extends EventEmitter {
             this.emit("message_failed", status); // ❌
         return false;
     }
+    /**
+     * True when a busy native-queue paste appears to have landed: Codex shows a
+     * `↳` queue marker, or a distinctive slice of the pasted text is on screen.
+     * Used only to detect silent paste loss — not as a general ready check.
+     */
+    async nativeQueuePasteVisible(formatted) {
+        if (!this.tmux)
+            return false;
+        try {
+            const pane = await this.tmux.capturePane();
+            if (pane.includes("↳"))
+                return true;
+            for (const line of formatted.split(/\r?\n/)) {
+                const t = line.trim();
+                if (t.length >= 8 && pane.includes(t))
+                    return true;
+            }
+            const compact = formatted.replace(/\s+/g, " ").trim();
+            if (compact.length >= 8 && pane.includes(compact.slice(0, Math.min(80, compact.length)))) {
+                return true;
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
     /** Re-resolve this instance's tmux window by name (stale id after crash/respawn). */
     async recoverWindow() {
         try {
@@ -2124,6 +2228,9 @@ export class Daemon extends EventEmitter {
             AGEND_SOCKET_PATH: sockPath,
             AGEND_INSTANCE_NAME: this.name,
             AGEND_WORKING_DIR: this.config.working_directory,
+            AGEND_INSTANCE_KIND: this.runtimeIdentity?.kind ?? "fleet-topic",
+            AGEND_BACKEND: this.runtimeIdentity?.backend ?? this.config.backend ?? this.backend?.binaryName ?? "unknown",
+            AGEND_MODEL: this.runtimeIdentity?.model ?? this.config.model ?? "default",
         };
         if (this.config.tool_set)
             mcpEnv.AGEND_TOOL_SET = this.config.tool_set;
@@ -2159,6 +2266,7 @@ export class Daemon extends EventEmitter {
             instructions = buildFleetInstructions({
                 instanceName: this.name,
                 workingDirectory: this.config.working_directory,
+                runtimeIdentity: this.runtimeIdentity,
                 displayName: this.config.display_name,
                 description: this.config.description,
                 customPrompt: resolvedCustomPrompt,
@@ -2171,6 +2279,7 @@ export class Daemon extends EventEmitter {
             instructions = buildFleetInstructions({
                 instanceName: this.name,
                 workingDirectory: this.config.working_directory,
+                runtimeIdentity: this.runtimeIdentity,
                 displayName: this.config.display_name,
                 description: this.config.description,
                 customPrompt: resolvedCustomPrompt,
@@ -2366,7 +2475,9 @@ export class Daemon extends EventEmitter {
             this.logger.warn({ err }, "Failed to set remain-on-exit — exit codes will not be captured");
         });
         if (reuseWindow && !this.config.lightweight) {
-            await this.tmux.pipeOutput(join(this.instanceDir, "output.log")).catch(err => {
+            const outputLog = join(this.instanceDir, "output.log");
+            rotateLogIfNeeded(outputLog);
+            await this.tmux.pipeOutput(outputLog).catch(err => {
                 this.logger.warn({ err }, "Failed to restore pipe-pane after wake");
             });
         }