@songsid/agend 2.1.1-beta.11 → 2.1.1-beta.13

package/dist/daemon.js

@@ -3,6 +3,8 @@ 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 { mcpServerState } from "./mcp-liveness.js";
 import { clearPausedMarker, writePausedMarker } from "./pause-marker.js";
 import { TmuxManager, resolveTmuxLogicalSize } from "./tmux-manager.js";
 import { TranscriptMonitor } from "./transcript-monitor.js";
@@ -40,6 +42,51 @@ export const DEFAULT_STATE_SAFETY_SWEEP_MS = 60_000;
 /** @deprecated State detection is event-driven; this now aliases the safety sweep. */
 export const DEFAULT_STATE_POLL_INTERVAL_MS = DEFAULT_STATE_SAFETY_SWEEP_MS;
 const LAST_INBOUND_FILE = "last-inbound-at";
+/**
+ * Whether two working directories belong to the same project, so a fleet-scoped
+ * decision recorded in one reaches the other. Covers the worktree/checkout
+ * layout AgEnD fleets actually use — `AgEnD`, `AgEnD-dev1`, `AgEnD-dev2`,
+ * `AgEnD-reviewer`, `AgEnD-main` are one project; `DouPo_Server` is not.
+ * Nesting counts too (a subdirectory of a project belongs to it).
+ */
+export function sameProjectFamily(a, b) {
+    const norm = (p) => p.replace(/\/+$/, "");
+    const x = norm(a), y = norm(b);
+    if (x === y)
+        return true;
+    if (x.startsWith(y + "/") || y.startsWith(x + "/"))
+        return true;
+    // Strip a trailing worktree/role suffix: "AgEnD-dev2" → "agend".
+    const family = (p) => {
+        const base = p.slice(p.lastIndexOf("/") + 1).toLowerCase();
+        return base.replace(/[-_](dev\d*|main|reviewer|tester|leader|sol|codex|worktree|wt\d*)$/i, "");
+    };
+    const fx = family(x), fy = family(y);
+    return fx.length > 0 && fx === fy;
+}
+/**
+ * Pick the decisions worth injecting into one instance's system prompt.
+ *
+ * `scope: "fleet"` previously bypassed the project check outright, so every
+ * instance carried every other project's playbook — measured at 8 of 14 here,
+ * resent on every API call. A fleet decision must now also be relevant: global
+ * (no project_root), the same project, or the same project family.
+ *
+ * `isDispatcher` (a general) opts out of that narrowing on purpose: it routes
+ * work across all projects, so cross-project rules ("X 文件操作由 Y 負責") are
+ * precisely what it must know. Narrowing a general would cause misrouting.
+ */
+export function selectRelevantDecisions(all, workDir, isDispatcher = false) {
+    return all.filter(d => {
+        if (d.project_root === workDir)
+            return true; // own project, any scope
+        if (d.scope !== "fleet")
+            return false; // project-scoped, elsewhere
+        if (!d.project_root)
+            return true; // truly global
+        return isDispatcher || sameProjectFamily(d.project_root, workDir);
+    });
+}
 /** Read the last real channel inbound timestamp persisted across daemon restarts. */
 export function readLastInboundAt(instanceDir, now = Date.now()) {
     try {
@@ -193,6 +240,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 +293,7 @@ export class Daemon extends EventEmitter {
     topicMode;
     backend;
     controlClient;
+    runtimeIdentity;
     logger;
     tmuxSessionName;
     tmux = null;
@@ -305,6 +355,13 @@ export class Daemon extends EventEmitter {
     statePollInFlight = false;
     autoPauseController;
     pauseRequested = false;
+    /**
+     * Sticky "pause as soon as possible" (auth failure). Unlike pauseRequested —
+     * which the state monitor clears whenever the pane is not idle — this survives
+     * busy/stuck states, because an auth error fires mid-turn and a plain pause()
+     * would silently no-op exactly when we most need to stop feeding the CLI.
+     */
+    pausePending = false;
     pauseWakeState = "active";
     pauseWakeTransition = null;
     // Model failover: override model on next spawn when rate-limited
@@ -327,6 +384,10 @@ export class Daemon extends EventEmitter {
     firstDeliveryDelay = new FirstDeliveryDelay();
     // PTY error pattern monitoring
     errorMonitorTimer = null;
+    /** Same 5-min gate the error monitor uses, so a dead MCP server alerts once. */
+    static MCP_DEATH_COOLDOWN_MS = 5 * 60_000;
+    lastMcpDeathNotifiedAt = 0;
+    mcpDeathNotifiedForPid = null;
     /** Prevent in-flight monitor callbacks from re-arming after a pause. */
     runtimeMonitorsFrozen = false;
     errorWaitingForRecovery = false; // true = error detected, waiting for ready pattern
@@ -371,7 +432,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 +440,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 +679,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);
@@ -677,6 +748,40 @@ export class Daemon extends EventEmitter {
         this.startInstanceStateMonitor();
         this.logger.info(`${this.name} ready`);
     }
+    /**
+     * Detect a CRASHED MCP server and report it once.
+     *
+     * The MCP server writes its pid to channel.mcp.pid at startup and unlinks it on
+     * a clean exit, so "file present + pid dead" specifically means it died without
+     * cleaning up (crash / OOM / SIGKILL). A missing file is either "not started
+     * yet" or "exited cleanly" — neither is an incident, and an orphan exit implies
+     * the CLI itself died, which the crash detector already covers.
+     *
+     * The daemon deliberately does NOT try to respawn it: MCP is a stdio protocol
+     * where the CLI spawns the server and owns its pipes, so a daemon-spawned
+     * process would have no client reading it. Only the CLI can restore its own
+     * tools — hence notify, and let the operator decide about restarting.
+     */
+    checkMcpServerAlive() {
+        if (this.isPaused)
+            return;
+        const status = mcpServerState(this.instanceDir);
+        if (status.state === "unknown")
+            return;
+        if (status.state === "alive") {
+            this.mcpDeathNotifiedForPid = null; // the CLI respawned it — re-arm
+            return;
+        }
+        // Dead: report once per pid, and at most once per cooldown window.
+        if (this.mcpDeathNotifiedForPid === status.pid)
+            return;
+        if (Date.now() - this.lastMcpDeathNotifiedAt < Daemon.MCP_DEATH_COOLDOWN_MS)
+            return;
+        this.mcpDeathNotifiedForPid = status.pid;
+        this.lastMcpDeathNotifiedAt = Date.now();
+        this.logger.error({ pid: status.pid }, "MCP server process is gone — instance has no agend tools");
+        this.emit("mcp_died", { name: this.name, pid: status.pid });
+    }
     startHealthCheck() {
         if (this.runtimeMonitorsFrozen || this.healthCheckTimer)
             return;
@@ -706,6 +811,8 @@ export class Daemon extends EventEmitter {
                     scheduleNext();
                     return;
                 }
+                // The CLI owns the MCP server process, so the daemon can only observe it.
+                this.checkMcpServerAlive();
                 // Human-readable backend label for logs (e.g. "claude", "kiro-cli")
                 const cliLabel = this.backend?.binaryName ?? "CLI";
                 let paneStatus = await this.tmux.getPaneStatus();
@@ -716,6 +823,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;
                 }
@@ -1241,6 +1353,16 @@ export class Daemon extends EventEmitter {
         };
     }
     /** Gracefully stop the CLI while keeping its remain-on-exit tmux window. */
+    /**
+     * Mark the instance to pause as soon as its pane is idle. Used for auth
+     * failures: pause() alone no-ops while the CLI is busy/stuck, which is the
+     * usual state when the error surfaces. Cleared by a successful pause or wake.
+     */
+    requestPauseWhenIdle() {
+        if (this.pauseWakeState === "paused")
+            return;
+        this.pausePending = true;
+    }
     async pause() {
         if (this.pauseWakeState === "paused")
             return;
@@ -1310,6 +1432,9 @@ export class Daemon extends EventEmitter {
     }
     /** Respawn the CLI in the preserved window and block until its prompt is ready. */
     async wake(timeoutMs = 30_000) {
+        // An explicit wake (e.g. after the user re-logs in) cancels a deferred
+        // auth pause — otherwise the instance would pause again the moment it idles.
+        this.pausePending = false;
         if (this.pauseWakeState === "active")
             return;
         if (this.pauseWakeState === "pausing")
@@ -1389,6 +1514,12 @@ export class Daemon extends EventEmitter {
         }
         if (snapshot.state !== "idle")
             this.pauseRequested = false;
+        // A pause deferred by an auth failure: retry the moment the pane settles.
+        if (this.pausePending && snapshot.state === "idle" && this.pasteQueueDepth === 0) {
+            this.pausePending = false;
+            this.emit("auto_pause_requested", { name: this.name, idleSince: snapshot.stateChangedAt });
+            return;
+        }
         if (!this.pauseRequested && this.pasteQueueDepth === 0 && this.autoPauseController.observe(snapshot.state)) {
             this.pauseRequested = true;
             this.emit("auto_pause_requested", { name: this.name, idleSince: snapshot.stateChangedAt });
@@ -1755,18 +1886,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 +1908,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 +1949,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 +2024,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 {
@@ -2110,7 +2326,14 @@ export class Daemon extends EventEmitter {
             try {
                 const all = JSON.parse(process.env.AGEND_DECISIONS);
                 const workDir = this.config.working_directory;
-                decisions = all.filter(d => d.scope === "fleet" || d.project_root === workDir);
+                // `scope: "fleet"` used to bypass the project check entirely, so a
+                // single-project worker inherited every other project's playbook (8 of
+                // 14 injected here were foreign) — resent on every API call. Now a
+                // fleet decision must also be RELEVANT: global (no project_root), the
+                // same project, or the same project family (worktrees/checkouts of one
+                // repo). A general is exempt: it dispatches across all projects, so
+                // cross-project routing rules are exactly what it needs.
+                decisions = selectRelevantDecisions(all, workDir, this.config.general_topic === true);
                 // Stable ordering so identical decision sets always build byte-identical
                 // instructions — otherwise source ordering jitter flips the warmup hash.
                 decisions.sort((a, b) => a.title.localeCompare(b.title));
@@ -2124,9 +2347,18 @@ 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;
+        // A general is a dispatcher, not a worker: default it to the `general` tool
+        // profile instead of `full`. Every tool's schema is resent on every API call,
+        // so full (44 tools) costs a general ~22k chars per turn — the single largest
+        // slice of its prompt. Explicit config still wins.
+        const defaultToolSet = this.config.general_topic ? "general" : undefined;
+        const toolSet = this.config.tool_set ?? defaultToolSet;
+        if (toolSet)
+            mcpEnv.AGEND_TOOL_SET = toolSet;
         if (this.config.display_name)
             mcpEnv.AGEND_DISPLAY_NAME = this.config.display_name;
         if (this.config.description)
@@ -2159,6 +2391,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 +2404,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 +2600,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");
             });
         }