@songsid/agend 2.1.0 → 2.1.1-beta.10

package/dist/daemon.d.ts

@@ -198,12 +198,23 @@ export declare class Daemon extends EventEmitter {
     private startErrorMonitor;
     /** Evaluate one pane snapshot. Kept synchronous so state-machine edges are unit-testable. */
     private evaluateErrorPatterns;
+    /**
+     * Notification text for a detected pattern. `formatMessage` patterns build it
+     * from the match so the user gets the specifics (e.g. which period and what
+     * percentage remains) instead of a generic "running low".
+     *
+     * Uses the LAST match in the pane: an older warning may still be scrolled up
+     * (10% earlier, 5% now), and the newest one is the one worth reporting.
+     */
+    private resolveErrorMessage;
     /**
      * Interrupt the CLI's current generation (cancel button / `/cancel`).
      * Direct tmux key event (not a paste) so it registers as the interrupt key.
      * kiro-cli interrupts on Ctrl+C; the others (claude-code, codex, …) on Escape.
      */
     sendEscape(): Promise<void>;
+    /** Send the backend-specific graceful quit command/key sequence. */
+    private sendQuitSequence;
     stop(): Promise<void>;
     getHangDetector(): HangDetector | null;
     getInstanceState(): InstanceState | "paused";

package/dist/daemon.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from "node:url";
 import { createHash, randomBytes } from "node:crypto";
 import { EventEmitter } from "node:events";
 import { clearPausedMarker, writePausedMarker } from "./pause-marker.js";
-import { TmuxManager } from "./tmux-manager.js";
+import { TmuxManager, resolveTmuxLogicalSize } from "./tmux-manager.js";
 import { TranscriptMonitor } from "./transcript-monitor.js";
 import { ContextGuardian } from "./context-guardian.js";
 import { IpcServer } from "./channel/ipc-bridge.js";
@@ -543,7 +543,7 @@ export class Daemon extends EventEmitter {
         });
         // 2. Tmux — ensure session, create window if not alive
         await TmuxManager.ensureSession(this.tmuxSessionName);
-        this.tmux = new TmuxManager(this.tmuxSessionName, "");
+        this.tmux = new TmuxManager(this.tmuxSessionName, "", resolveTmuxLogicalSize(this.config.terminal));
         // Strategy A: always start fresh Claude window (MCP server has no reconnection)
         // Kill any existing window from previous run
         const windowIdFile = join(this.instanceDir, "window-id");
@@ -1101,11 +1101,35 @@ export class Daemon extends EventEmitter {
             this.lastErrorNotifiedAt.set(key, now);
             if (ep.action === "failover")
                 this.lastFailoverAt = now;
-            this.logger.warn({ errorType: ep.type, action: ep.action }, `PTY error detected: ${ep.message}`);
-            this.emit("pty_error", { name: this.name, ...ep });
+            const message = this.resolveErrorMessage(pane, ep);
+            this.logger.warn({ errorType: ep.type, action: ep.action }, `PTY error detected: ${message}`);
+            this.emit("pty_error", { name: this.name, ...ep, message });
             break; // Only handle first unsuppressed new error per scan
         }
     }
+    /**
+     * Notification text for a detected pattern. `formatMessage` patterns build it
+     * from the match so the user gets the specifics (e.g. which period and what
+     * percentage remains) instead of a generic "running low".
+     *
+     * Uses the LAST match in the pane: an older warning may still be scrolled up
+     * (10% earlier, 5% now), and the newest one is the one worth reporting.
+     */
+    resolveErrorMessage(pane, ep) {
+        if (!ep.formatMessage)
+            return ep.message;
+        try {
+            const flags = ep.pattern.flags.includes("g") ? ep.pattern.flags : ep.pattern.flags + "g";
+            const matches = [...pane.matchAll(new RegExp(ep.pattern.source, flags))];
+            const last = matches[matches.length - 1];
+            return last ? ep.formatMessage(last) : ep.message;
+        }
+        catch (err) {
+            // A bad formatter must not swallow the notification entirely.
+            this.logger.debug({ err, errorType: ep.type }, "formatMessage failed — using static message");
+            return ep.message;
+        }
+    }
     /**
      * Interrupt the CLI's current generation (cancel button / `/cancel`).
      * Direct tmux key event (not a paste) so it registers as the interrupt key.
@@ -1115,6 +1139,30 @@ export class Daemon extends EventEmitter {
         const cancelKey = this.backend?.getCancelKey() ?? "Escape";
         await this.tmux?.sendSpecialKey(cancelKey);
     }
+    /** Send the backend-specific graceful quit command/key sequence. */
+    async sendQuitSequence() {
+        if (!this.tmux || !this.backend)
+            return false;
+        const quitCmd = this.backend.getQuitCommand();
+        const quitKey = this.backend.getQuitKey?.();
+        if (quitCmd) {
+            await this.tmux.sendKeys(quitCmd);
+            // Delay before Enter to prevent tmux server races when instances stop in
+            // parallel (same pattern as pasteText).
+            await new Promise(r => setTimeout(r, 150));
+            await this.tmux.sendSpecialKey("Enter");
+            return true;
+        }
+        if (!quitKey)
+            return false;
+        const presses = Math.max(1, Math.floor(this.backend.getQuitKeyPresses?.() ?? 1));
+        for (let i = 0; i < presses; i++) {
+            await this.tmux.sendSpecialKey(quitKey);
+            if (i + 1 < presses)
+                await new Promise(r => setTimeout(r, 250));
+        }
+        return true;
+    }
     async stop() {
         this.logger.info("Stopping daemon instance");
         this.freezeRuntimeMonitors();
@@ -1134,20 +1182,8 @@ export class Daemon extends EventEmitter {
             this.saveSessionId();
             this.healthCheckPaused = true;
             let killed = false;
-            const quitCmd = this.backend?.getQuitCommand();
-            const quitKey = this.backend?.getQuitKey?.();
-            if (quitCmd) {
-                await this.tmux.sendKeys(quitCmd);
-                // Delay before Enter to prevent tmux server race when multiple
-                // instances stop in parallel (same pattern as pasteText).
-                await new Promise(r => setTimeout(r, 150));
-                await this.tmux.sendSpecialKey("Enter");
-            }
-            else if (quitKey) {
-                // Some CLIs quit via a key chord (e.g. grok Ctrl+Q), not a typed command.
-                await this.tmux.sendSpecialKey(quitKey);
-            }
-            if (quitCmd || quitKey) {
+            const quitSent = await this.sendQuitSequence();
+            if (quitSent) {
                 // Wait up to 3s for graceful exit, polling every 200ms. A healthy CLI
                 // exits within ~1s; a longer wait just delays the force-kill fallback.
                 for (let i = 0; i < 15; i++) {
@@ -1223,19 +1259,7 @@ export class Daemon extends EventEmitter {
         const transition = (async () => {
             try {
                 this.saveSessionId();
-                const quitCmd = this.backend?.getQuitCommand();
-                const quitKey = this.backend?.getQuitKey?.();
-                if (this.tmux) {
-                    if (quitCmd) {
-                        await this.tmux.sendKeys(quitCmd);
-                        await new Promise(r => setTimeout(r, 150));
-                        await this.tmux.sendSpecialKey("Enter");
-                    }
-                    else if (quitKey) {
-                        // Key-chord quit (e.g. grok Ctrl+Q) — no typed command to send.
-                        await this.tmux.sendSpecialKey(quitKey);
-                    }
-                }
+                await this.sendQuitSequence();
                 let exited = false;
                 for (let i = 0; i < 15; i++) {
                     await new Promise(r => setTimeout(r, 200));
@@ -1818,7 +1842,7 @@ export class Daemon extends EventEmitter {
             const match = windows.find(w => w.name === this.name);
             if (!match)
                 return undefined;
-            this.tmux = new TmuxManager(this.tmuxSessionName, match.id);
+            this.tmux = new TmuxManager(this.tmuxSessionName, match.id, resolveTmuxLogicalSize(this.config.terminal));
             writeFileSync(join(this.instanceDir, "window-id"), match.id);
             await this.controlClient?.registerWindow(match.id);
             this.bindInstanceStateOutputListener(match.id);