@songsid/agend 2.1.6 → 2.1.7-beta.2

package/dist/daemon.js

@@ -37,11 +37,17 @@ const CROSS_INSTANCE_TOOLS = new Set(["send_to_instance", "list_instances", "sta
 const SCHEDULE_TOOLS = new Set(["create_schedule", "list_schedules", "update_schedule", "delete_schedule"]);
 const DECISION_TOOLS = new Set(["post_decision", "list_decisions", "update_decision"]);
 const TASK_TOOL = "task";
-// Tools whose success proves the agent got a message out this turn. While any
-// of these succeeded, a dead-MCP proxy reply would double-post — suppress it.
-const TURN_REPLY_TOOLS = new Set(["reply", "send_to_instance", "report_result", "request_information", "delegate_task", "broadcast"]);
+// Tools whose success proves the agent performed an outbound action this turn.
+// While any of these succeeded, a dead-MCP proxy reply would duplicate output.
+const TURN_OUTBOUND_TOOLS = new Set([
+    "reply", "react", "edit_message", "send_to_instance", "report_result",
+    "request_information", "delegate_task", "broadcast",
+]);
+// These actions reach the human-facing channel and satisfy reply-completion:
+// a deliberate reaction or edit is a valid response even without new text.
+const TURN_COMPLETION_TOOLS = new Set(["reply", "react", "edit_message"]);
 const REPLY_DROP_WARNING_COOLDOWN_MS = 5 * 60_000;
-const REPLY_RECOVERY_PROMPT = "[system:reply-required] The previous human-facing turn ended without a successfully delivered reply. Do not redo the work. Use the reply tool exactly once now to send the user a concise conclusion. If no substantive answer is needed, send a brief acknowledgement. Do not reply to this system instruction except through the reply tool.";
+const REPLY_RECOVERY_PROMPT = "[system:reply-required] The previous human-facing turn ended without a successfully delivered reply. Do not redo the work. React with an emoji or use the reply tool exactly once now to send the user a concise conclusion. If no substantive answer is needed, a brief react is sufficient. Do not reply to this system instruction except through the react or reply tool.";
 /** Point a resumed CLI at its one backend-native instruction source. */
 export function buildInstructionReloadNotice(binaryName, instanceName, instanceDir) {
     const source = binaryName === "codex" || binaryName === "grok" || binaryName === "muse"
@@ -495,6 +501,15 @@ const INPUT_TRANSIENT_WAIT_MS = 10 * 60_000;
 const INPUT_TRANSIENT_POLL_MS = 250;
 /** Max "stranded text → submit → wait for prompt → re-check" rounds per delivery; each may send one recovery Enter. */
 const STRANDED_INPUT_MAX_ROUNDS = 3;
+/** Build a status holder from channel metadata, keeping chat and thread apart. */
+function channelStatus(meta) {
+    const chatId = meta.chat_id;
+    const messageId = meta.message_id;
+    if (!chatId || !messageId)
+        return undefined;
+    const threadId = meta.thread_id || undefined;
+    return threadId ? { chatId, messageId, threadId } : { chatId, messageId };
+}
 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. */
@@ -1214,10 +1229,26 @@ export class Daemon extends EventEmitter {
     // capture buffer the count drops — we lower the baseline so a re-occurrence
     // still registers as new (prevents the old hash-dedup's permanent suppression).
     lastErrorCount = new Map();
+    // A lifecycle-provided count is a lower bound while a restarted Codex pane is
+    // still booting. Its new tmux window starts empty before resume restores the
+    // old transcript, so pre-ready scans must not lower this seeded baseline.
+    seededErrorCountBaselines = new Map();
     lastDetectedErrorType = null;
     static errorPatternKey(ep) {
         return `${ep.type}:${ep.pattern.source}`;
     }
+    /** Read the occurrence baseline so a lifecycle-owned restart can carry it forward. */
+    getErrorPatternOccurrenceCount(type, pattern) {
+        return this.lastErrorCount.get(`${type}:${pattern.source}`) ?? 0;
+    }
+    /** Seed a replacement daemon with an already-reported pattern count. */
+    seedErrorPatternOccurrenceCount(type, pattern, count) {
+        if (!Number.isSafeInteger(count) || count <= 0)
+            return;
+        const key = `${type}:${pattern.source}`;
+        this.lastErrorCount.set(key, count);
+        this.seededErrorCountBaselines.set(key, count);
+    }
     /**
      * Undo the auth suspicion a pattern match armed, once the backend's token-free
      * probe has said the credentials are fine.
@@ -2440,6 +2471,23 @@ export class Daemon extends EventEmitter {
         // notification, a false recovery log, then silence.
         const looksReady = () => !busyPattern?.test(pane) && readyPattern.test(pane);
         const codexLivePane = this.isCodexLivePaneSnapshot(pane);
+        const rebasedSeededBaselines = new Set();
+        // The baseline belongs to the resumed transcript, not the empty startup
+        // frame from the replacement tmux window. Keep it as a floor until resume
+        // presents a live composer, then rebase to the lower of the pane's actual
+        // count and the seed. Any higher count already includes a new occurrence,
+        // which the normal scan below must still report.
+        if (codexLivePane && this.seededErrorCountBaselines.size > 0) {
+            for (const [key, seed] of this.seededErrorCountBaselines) {
+                const ep = patterns.find(candidate => Daemon.errorPatternKey(candidate) === key);
+                if (ep)
+                    this.lastErrorCount.set(key, Math.min(countMatches(ep.pattern), seed));
+                this.seededErrorCountBaselines.delete(key);
+                // Do not let the generic scrolling-count path repeat this rebase if the
+                // live-pane assignment above is removed or changed (#949 mutation guard).
+                rebasedSeededBaselines.add(key);
+            }
+        }
         // State: waiting for recovery. A missing/outdated ready pattern must not
         // suppress every future error forever, so the gate has a hard deadline.
         if (this.errorWaitingForRecovery) {
@@ -2517,8 +2565,11 @@ export class Daemon extends EventEmitter {
             if (count <= seen) {
                 // Occurrences scrolled out of the capture buffer → lower the baseline
                 // so a future re-occurrence still counts as new (no permanent suppress).
-                if (count < seen)
+                // A seeded Codex count stays a floor until resume reaches a live composer;
+                // an empty startup frame is not evidence that its history scrolled away.
+                if (count < seen && !this.seededErrorCountBaselines.has(key) && !rebasedSeededBaselines.has(key)) {
                     this.lastErrorCount.set(key, count);
+                }
                 continue;
             }
             // count > seen → a NEW occurrence of this exact pattern appeared.
@@ -3211,7 +3262,7 @@ export class Daemon extends EventEmitter {
         const turn = this.turnReplyGuard.snapshot();
         if (!turn || this.isPaused)
             return;
-        if (turn.replyDelivered) {
+        if (turn.completionDelivered) {
             if (turn.phase === "recovering") {
                 this.emit("reply_drop_recovered", {
                     name: this.name,
@@ -3269,9 +3320,9 @@ export class Daemon extends EventEmitter {
                 return;
             }
         }
-        // Preserve the dead-MCP proxy path and its explicit opt-in. Other outbound
-        // tools still suppress that proxy, but only a delivered `reply` satisfies
-        // the human-facing completion guard below.
+        // Preserve the dead-MCP proxy path and its explicit opt-in. Any verified
+        // outbound action suppresses a duplicate proxy; only a delivered
+        // human-facing channel action satisfies the completion guard below.
         if (!turn.outboundDelivered && this.config.mcp_proxy_reply === true
             && mcpServerState(this.instanceDir).state === "dead") {
             this.turnReplyGuard.complete(turn.generation);
@@ -3331,7 +3382,7 @@ export class Daemon extends EventEmitter {
                 const current = this.turnReplyGuard.snapshot();
                 if (!current || current.generation !== turn.generation || current.phase !== "recovering")
                     return;
-                if (current.replyDelivered) {
+                if (current.completionDelivered) {
                     this.turnReplyGuard.complete(turn.generation);
                     this.emit("reply_drop_recovered", {
                         name: this.name,
@@ -4204,11 +4255,7 @@ export class Daemon extends EventEmitter {
         this.recordRecentUserMessage(content, meta);
         const formatted = "[STEERING — mid-task course correction. Fold this into the CURRENT work if one is active.]\n"
             + this.formatInboundMessage(content, meta);
-        const chatId = meta.chat_id;
-        const messageId = meta.message_id;
-        const status = (chatId && messageId)
-            ? { chatId: meta.thread_id || chatId, messageId }
-            : undefined;
+        const status = channelStatus(meta);
         this.steerLock = this.steerLock.then(async () => {
             if (!this.isDeliveryEpochCurrent(deliveryEpoch))
                 return;
@@ -4246,11 +4293,7 @@ export class Daemon extends EventEmitter {
         this.recordRecentUserMessage(content, meta);
         const formatted = "[BTW — side question from the user. Answer it separately without changing or interrupting the CURRENT work.]\n"
             + this.formatInboundMessage(content, meta);
-        const chatId = meta.chat_id;
-        const messageId = meta.message_id;
-        const status = (chatId && messageId)
-            ? { chatId: meta.thread_id || chatId, messageId }
-            : undefined;
+        const status = channelStatus(meta);
         this.steerLock = this.steerLock.then(async () => {
             if (!this.isDeliveryEpochCurrent(deliveryEpoch))
                 return;
@@ -4327,7 +4370,9 @@ export class Daemon extends EventEmitter {
             this.logger.warn({ depth: this.pasteQueueDepth }, "Message delivery queue backing up");
         }
         if (wasQueued && chatId && messageId) {
-            this.emit("message_queued", { chatId: meta.thread_id || chatId, messageId });
+            const queuedStatus = channelStatus(meta);
+            if (queuedStatus)
+                this.emit("message_queued", queuedStatus);
         }
         this.pasteLock = this.pasteLock.then(async () => {
             try {
@@ -4346,9 +4391,7 @@ export class Daemon extends EventEmitter {
                     if (!this.isDeliveryEpochCurrent(deliveryEpoch))
                         return;
                 }
-                const status = (chatId && messageId)
-                    ? { chatId: meta.thread_id || chatId, messageId }
-                    : undefined;
+                const status = channelStatus(meta);
                 // A fresh delivery begins a fresh turn — its bubble must not inherit
                 // the previous turn's tool list.
                 this.resetToolProgress();
@@ -6050,14 +6093,14 @@ export class Daemon extends EventEmitter {
         // an unmapped socket is retained for legacy/tests where mcp_ready was not
         // observed before the first tool call.
         const sourceSession = this.socketSessionNames.get(socket);
-        const replyAttempt = TURN_REPLY_TOOLS.has(tool) && (!sourceSession || sourceSession === this.name)
-            ? this.turnReplyGuard.beginToolAttempt(tool === "reply")
+        const replyAttempt = TURN_OUTBOUND_TOOLS.has(tool) && (!sourceSession || sourceSession === this.name)
+            ? this.turnReplyGuard.beginToolAttempt(tool === "reply", TURN_COMPLETION_TOOLS.has(tool))
             : null;
         // For now, log and respond. Full adapter routing will be wired in fleet manager.
         const respond = (result, error) => {
             // A message that verifiably went out stands down the dead-MCP proxy reply
             // for this turn: the agent proved it can still speak for itself.
-            if (!error && result != null && TURN_REPLY_TOOLS.has(tool)) {
+            if (!error && result != null && TURN_OUTBOUND_TOOLS.has(tool)) {
                 this.turnReplyGuard.settleToolAttempt(replyAttempt, true);
             }
             const sent = this.ipcServer?.send(socket, { requestId, result, error }) ?? false;