@agentchatme/agent-core 0.0.1313 → 0.0.1313111

package/dist/daemon-entry.d.ts

@@ -102,6 +102,14 @@ interface CoordConfig {
     holder: string;
     timeoutMs?: number;
 }
+interface ClaimOutcome {
+    claimed: boolean;
+    deferred: boolean;
+}
+interface ClaimBatchOutcome {
+    claimedCount: number;
+    deferred: boolean;
+}
 declare class ReplyCoord {
     private readonly cfg;
     constructor(cfg: CoordConfig);
@@ -109,17 +117,16 @@ declare class ReplyCoord {
     /** Is the agent's live coding session actively working? Fail-open → FALSE. */
     isSessionActive(): Promise<boolean>;
     /**
-     * Claim the sole right to reply to a message. Returns true if THIS daemon is
-     * the designated replier, false if a live session already owns it. Fail-open
-     * → TRUE (reply anyway rather than drop).
+     * Claim the sole right to reply to a message, atomically respecting any
+     * foreground turn. Fail-open → claimed (reply anyway rather than drop).
      */
-    claim(messageId: string): Promise<boolean>;
+    claim(messageId: string): Promise<ClaimOutcome>;
     /**
      * Claim the contiguous oldest-first prefix of one conversation batch.
      * Falls back to ordered single-message claims against an older API server;
      * all other coordination failures remain fail-open.
      */
-    claimBatch(messageIds: string[]): Promise<number>;
+    claimBatch(messageIds: string[]): Promise<ClaimBatchOutcome>;
 }
 
 interface TurnMentionContext {
@@ -281,6 +288,7 @@ declare class Daemon {
     private pending;
     private inFlight;
     private readonly waiters;
+    private foregroundClaimsBlockedUntil;
     private stopping;
     private heartbeatTimer;
     constructor(cfg: DaemonConfig, adapter: RuntimeAdapter, ws?: AgentWsClient, // injectable for tests; defaults to a real socket
@@ -295,6 +303,7 @@ declare class Daemon {
     /** Process bounded backlog snapshots, in arrival order within a conversation. */
     private drainConversation;
     private handleNextBatch;
+    private waitForForegroundClaimWindow;
     private turnContext;
     private markHandled;
     private markNoLongerPending;

package/dist/daemon-entry.js

@@ -10,7 +10,7 @@ import {
   idle,
   log,
   resolveIdentity
-} from "./chunk-27XDHOL3.js";
+} from "./chunk-YWX7E5VW.js";
 
 // src/daemon/ws-client.ts
 import { WebSocket } from "ws";
@@ -309,20 +309,23 @@ var ReplyCoord = class {
     }
   }
   /**
-   * Claim the sole right to reply to a message. Returns true if THIS daemon is
-   * the designated replier, false if a live session already owns it. Fail-open
-   * → TRUE (reply anyway rather than drop).
+   * Claim the sole right to reply to a message, atomically respecting any
+   * foreground turn. Fail-open → claimed (reply anyway rather than drop).
    */
   async claim(messageId) {
     try {
       const d = await this.req("POST", "/v1/reply/claim", {
         message_id: messageId,
-        holder: this.cfg.holder
+        holder: this.cfg.holder,
+        defer_if_active: true
       });
-      return d?.claimed !== false;
+      return {
+        claimed: d?.claimed !== false,
+        deferred: d?.deferred === true
+      };
     } catch (err) {
       log.debug(`coord claim failed (proceeding): ${String(err)}`);
-      return true;
+      return { claimed: true, deferred: false };
     }
   }
   /**
@@ -331,26 +334,33 @@ var ReplyCoord = class {
    * all other coordination failures remain fail-open.
    */
   async claimBatch(messageIds) {
-    if (messageIds.length === 0) return 0;
+    if (messageIds.length === 0) return { claimedCount: 0, deferred: false };
     try {
       const d = await this.req("POST", "/v1/reply/claim-batch", {
         message_ids: messageIds,
-        holder: this.cfg.holder
+        holder: this.cfg.holder,
+        defer_if_active: true
       });
       const count = d?.claimed_count;
-      return Number.isInteger(count) && count >= 0 && count <= messageIds.length ? count : messageIds.length;
+      return {
+        claimedCount: Number.isInteger(count) && count >= 0 && count <= messageIds.length ? count : messageIds.length,
+        deferred: d?.deferred === true
+      };
     } catch (err) {
       if (!/reply-coord (404|405)\b/.test(String(err))) {
         log.debug(`coord batch claim failed (proceeding with all): ${String(err)}`);
-        return messageIds.length;
+        return { claimedCount: messageIds.length, deferred: false };
       }
     }
     let claimed = 0;
     for (const messageId of messageIds) {
-      if (!await this.claim(messageId)) break;
+      const outcome = await this.claim(messageId);
+      if (!outcome.claimed) {
+        return { claimedCount: claimed, deferred: outcome.deferred };
+      }
       claimed += 1;
     }
-    return claimed;
+    return { claimedCount: claimed, deferred: false };
   }
 };
 
@@ -515,7 +525,10 @@ var RETRY_MAX_MS = Math.max(
   RETRY_BASE_MS,
   positiveBoundedEnv("AGENTCHATD_RETRY_MAX_MS", 5 * 6e4)
 );
-var YIELD_MS = Number(process.env["AGENTCHATD_YIELD_MS"] ?? 1e4);
+var FOREGROUND_RECHECK_MS = positiveBoundedEnv(
+  "AGENTCHATD_FOREGROUND_RECHECK_MS",
+  2e3
+);
 var delay = (ms) => new Promise((r) => setTimeout(r, ms));
 function retryDelay(attempt) {
   return Math.min(RETRY_BASE_MS * 2 ** Math.min(20, Math.max(0, attempt - 1)), RETRY_MAX_MS);
@@ -577,6 +590,10 @@ var Daemon = class {
   pending = 0;
   inFlight = 0;
   waiters = [];
+  // Identity-wide foreground priority, learned from any deferred claim. Every
+  // conversation shares this window so a large multi-conversation backlog
+  // cannot turn into one polling loop per conversation.
+  foregroundClaimsBlockedUntil = 0;
   stopping = false;
   heartbeatTimer = null;
   async start() {
@@ -648,14 +665,10 @@ var Daemon = class {
       this.convQueues.get(conversationId)?.shift();
       return;
     }
-    if (await this.coord.isSessionActive()) {
-      log.info(`msg ${first.id}: live session active \u2014 yielding for ${YIELD_MS}ms`);
-      await delay(YIELD_MS);
-      if (this.stopping) return;
-    }
     await this.acquireSlot();
     let slotHeld = true;
     try {
+      await this.waitForForegroundClaimWindow();
       if (this.stopping) {
         return;
       }
@@ -664,23 +677,77 @@ var Daemon = class {
       const queue = this.convQueues.get(conversationId);
       if (!queue || queue.length === 0) return;
       const candidates = queue.splice(0, MAX_BATCH_MESSAGES);
-      const claimedCount = await this.coord.claimBatch(
+      const claim = await this.coord.claimBatch(
         candidates.map((row) => row.id)
       );
-      const batch = candidates.slice(0, claimedCount);
+      const claimedCount = claim.claimedCount;
+      let batch = candidates.slice(0, claimedCount);
       if (claimedCount < candidates.length) {
-        const conflict = candidates[claimedCount];
-        log.info(`msg ${conflict.id}: claimed by the live session \u2014 standing down`);
-        this.seen.delete(conflict.id);
-        this.markNoLongerPending();
-        const unclaimedTail = candidates.slice(claimedCount + 1);
-        if (unclaimedTail.length > 0) {
-          const current = this.convQueues.get(conversationId) ?? [];
-          this.convQueues.set(conversationId, [...unclaimedTail, ...current]);
+        if (claim.deferred) {
+          this.foregroundClaimsBlockedUntil = Math.max(
+            this.foregroundClaimsBlockedUntil,
+            Date.now() + FOREGROUND_RECHECK_MS
+          );
+          const deferred = candidates.slice(claimedCount);
+          if (deferred.length > 0) {
+            const current = this.convQueues.get(conversationId) ?? [];
+            this.convQueues.set(conversationId, [...deferred, ...current]);
+          }
+          log.info(
+            `msg ${deferred[0]?.id}: foreground turn owns priority \u2014 deferring daemon claim`
+          );
+        } else {
+          const conflict = candidates[claimedCount];
+          log.info(`msg ${conflict.id}: claimed by the live session \u2014 standing down`);
+          this.seen.delete(conflict.id);
+          this.markNoLongerPending();
+          const unclaimedTail = candidates.slice(claimedCount + 1);
+          if (unclaimedTail.length > 0) {
+            const current = this.convQueues.get(conversationId) ?? [];
+            this.convQueues.set(conversationId, [...unclaimedTail, ...current]);
+          }
         }
       }
       if (batch.length === 0) return;
       while (!this.stopping) {
+        const renewed = await this.coord.claimBatch(batch.map((row) => row.id));
+        if (renewed.claimedCount < batch.length) {
+          const lost = batch.slice(renewed.claimedCount);
+          batch = batch.slice(0, renewed.claimedCount);
+          if (renewed.deferred) {
+            this.foregroundClaimsBlockedUntil = Math.max(
+              this.foregroundClaimsBlockedUntil,
+              Date.now() + FOREGROUND_RECHECK_MS
+            );
+            for (const row of lost) {
+              const state = this.seen.get(row.id);
+              if (state) {
+                state.status = "queued";
+                state.updatedAt = Date.now();
+              }
+            }
+            const current = this.convQueues.get(conversationId) ?? [];
+            this.convQueues.set(conversationId, [...lost, ...current]);
+          } else {
+            const conflict = lost[0];
+            log.info(`msg ${conflict.id}: renewal lost to a live session \u2014 standing down`);
+            this.seen.delete(conflict.id);
+            this.markNoLongerPending();
+            const tail = lost.slice(1);
+            for (const row of tail) {
+              const state = this.seen.get(row.id);
+              if (state) {
+                state.status = "queued";
+                state.updatedAt = Date.now();
+              }
+            }
+            if (tail.length > 0) {
+              const current = this.convQueues.get(conversationId) ?? [];
+              this.convQueues.set(conversationId, [...tail, ...current]);
+            }
+          }
+        }
+        if (batch.length === 0) return;
         const states = batch.map((row) => this.seen.get(row.id));
         if (states.some(
           (state) => state === void 0 || state.status === "handled"
@@ -736,6 +803,13 @@ var Daemon = class {
       if (slotHeld) this.releaseSlot();
     }
   }
+  async waitForForegroundClaimWindow() {
+    while (!this.stopping) {
+      const remaining = this.foregroundClaimsBlockedUntil - Date.now();
+      if (remaining <= 0) return;
+      await delay(remaining);
+    }
+  }
   turnContext(batch) {
     const focus = batch[batch.length - 1];
     const oldest = batch[0];