ework-daemon 0.4.64 → 0.4.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-daemon",
-  "version": "0.4.64",
+  "version": "0.4.66",
   "description": "Issue-driven AI development daemon. Spawns opencode subprocesses to resolve Gitea issues.",
   "module": "src/index.ts",
   "type": "module",

package/src/config.ts

@@ -74,6 +74,10 @@ export const configSchema = z.object({
     maxNudges: z.coerce.number().int().nonnegative(),
     maxRuntimeMs: z.coerce.number().positive(),
   }).optional(),
+  replyBurst: z.object({
+    max: z.coerce.number().int().positive(),
+    windowMs: z.coerce.number().positive(),
+  }).optional(),
   file: z.object({
     roots: z.array(z.string()).default([]),
     maxLines: z.coerce.number().int().positive().default(2000),
@@ -176,6 +180,10 @@ export function loadConfig(): Config {
         maxNudges: Number(process.env.DAEMON_MAX_STUCK_NUDGES) || 1,
         maxRuntimeMs: Number(process.env.DAEMON_STUCK_MAX_RUNTIME_MS) || 3 * 60 * 60 * 1000,
       } : undefined,
+      replyBurst: process.env.WORK_REPLY_BURST_MAX || process.env.WORK_REPLY_BURST_WINDOW_MS ? {
+        max: Number(process.env.WORK_REPLY_BURST_MAX) || 8,
+        windowMs: Number(process.env.WORK_REPLY_BURST_WINDOW_MS) || 5 * 60 * 1000,
+      } : undefined,
       childEnvDeny: (process.env.WORK_CHILD_ENV_DENY ?? "").split(",").map((s) => s.trim()).filter(Boolean),
     });
   }
@@ -224,6 +232,10 @@ export function loadConfig(): Config {
       maxNudges: Number(process.env.DAEMON_MAX_STUCK_NUDGES) || 1,
       maxRuntimeMs: Number(process.env.DAEMON_STUCK_MAX_RUNTIME_MS) || 3 * 60 * 60 * 1000,
     } : undefined,
+    replyBurst: process.env.WORK_REPLY_BURST_MAX || process.env.WORK_REPLY_BURST_WINDOW_MS ? {
+      max: Number(process.env.WORK_REPLY_BURST_MAX) || 8,
+      windowMs: Number(process.env.WORK_REPLY_BURST_WINDOW_MS) || 5 * 60 * 1000,
+    } : undefined,
     file: {
       roots: (process.env.WORK_FILE_ROOTS ?? "").split(":").filter(Boolean).length > 0
         ? (process.env.WORK_FILE_ROOTS ?? "").split(":").filter(Boolean)

package/src/opencode.ts

@@ -301,6 +301,7 @@ export interface EngineOptions {
   takeover?: TakeoverStrategy;
   backend?: RuntimeBackend;
   gateChecker?: (issue: Issue) => Promise<{ allowed: boolean; reason: string }>;
+  replyBurst?: { max: number; windowMs: number };
 }
 
 function createDefaultBackend(cfg: Config): RuntimeBackend {
@@ -331,6 +332,19 @@ export function wakePolicySkips(
   return null;
 }
 
+// Reply-burst circuit breaker state: prune timestamps to the sliding window,
+// trip when the retained count reaches max. Pure for testability.
+export function replyBurstState(
+  stamps: number[],
+  now: number,
+  max: number,
+  windowMs: number,
+): { tripped: boolean; kept: number[] } {
+  const kept = stamps.filter((t) => now - t < windowMs);
+  kept.push(now);
+  return { tripped: kept.length >= max, kept };
+}
+
 // Per-issue npm prefix: `npm install -g <pkg>` inside a session lands in the issue's
 // workdir instead of the system global, so concurrent agents debugging different
 // issues cannot clobber each other's global installs (nor poison the shared daemon env).
@@ -398,6 +412,8 @@ export class Engine {
   private altBackend?: RuntimeBackend;
   private senders = new Map<string, string>();
   private envInitialized = new Set<string>();
+  private replyBurstCfg?: { max: number; windowMs: number };
+  private replyStamps = new Map<string, number[]>();
 
   private static MAX_INLINE_SIZE = 4000;
   private static MAX_NUDGE_ROUNDS = 1;
@@ -406,6 +422,8 @@ export class Engine {
   private static MAX_RUNTIME_MS = 3 * 60 * 60 * 1000;
   private static OBSERVER_INTERVAL_MS = 5 * 60 * 1000;
   private static STUCK_THRESHOLD_MS = 30 * 60 * 1000;
+  private static MAX_REPLY_BURST = 8;
+  private static REPLY_BURST_WINDOW_MS = 5 * 60 * 1000;
   private static MAX_PROCESS_EXIT_NUDGE_ROUNDS = 1;
 
   constructor(cfg: Config, store: Store, trackers: TrackerRegistry, opts: EngineOptions) {
@@ -416,6 +434,7 @@ export class Engine {
     this.takeover = opts.takeover ?? new RecloneStrategy(cfg);
     this.backend = opts.backend ?? createDefaultBackend(cfg);
     this.gateChecker = opts.gateChecker ?? ((issue: Issue) => this.webGateAllows(issue));
+    this.replyBurstCfg = opts.replyBurst ?? cfg.replyBurst;
     this.maxConcurrent = cfg.work.maxConcurrent;
     this.maxConcurrentExplicit = cfg.work.maxConcurrentExplicit;
     this.startGlobalObserver();
@@ -768,6 +787,21 @@ export class Engine {
     const tracker = this.getTracker(ref.trackerType);
     const scopeKey = tracker.formatScopeKey(ref.scope);
 
+    // State bookkeeping that must survive every wake gate: `issue_closed` is
+    // never gated, so if a later `reopened` (mapped to issue_opened) is
+    // dropped by paused/halted/dispatch_off/wake gates, the row stays
+    // "closed" forever and swallows ALL future comments ("is closed in DB").
+    // Heal the stale state unconditionally; dispatch remains gated below.
+    if (event.type === "issue_opened") {
+      const existing = await this.store.findIssue(ref.trackerType, scopeKey, ref.issueId);
+      if (existing?.state === "closed") {
+        await this.store.updateIssueState(existing.id, "active");
+        log.info(
+          `engine: reopened — cleared stale closed state for ${ref.trackerType}:${scopeKey}#${ref.issueId} (bookkeeping only; dispatch still gated)`,
+        );
+      }
+    }
+
     if (this.paused && (event.type === "issue_opened" || event.type === "comment_created")) {
       log.info(`engine: paused — skipping ${event.type} for ${ref.trackerType}:${scopeKey}#${ref.issueId}`);
       return;
@@ -783,6 +817,13 @@ export class Engine {
       return;
     }
 
+    // Self-authored comment (our own reply landing back): never wake on it,
+    // but feed the reply-burst circuit breaker first.
+    if (event.type === "comment_created" && event.comment?.author === this.cfg.bot.username) {
+      await this.trackSelfReply(ref, scopeKey, tracker);
+      return;
+    }
+
     const wakeAuthor = event.type === "comment_created" ? event.comment?.author : event.type === "issue_opened" ? event.issue?.author : undefined;
     const wakeKind = event.type === "comment_created" ? event.comment?.authorKind ?? "human" : "human";
     if (wakeAuthor) {
@@ -822,6 +863,33 @@ export class Engine {
     }
   }
 
+  // Reply-burst circuit breaker: a looping session can re-perceive a standing
+  // instruction every agent turn and invoke the reply tool indefinitely. Our
+  // own replies come back as comment_created events, so count them per issue
+  // and kill the running sessions when they exceed max within the window.
+  private async trackSelfReply(ref: TrackerRef, scopeKey: string, tracker: IssueTracker) {
+    const key = `${ref.trackerType}:${scopeKey}#${ref.issueId}`;
+    const max = this.replyBurstCfg?.max ?? Engine.MAX_REPLY_BURST;
+    const windowMs = this.replyBurstCfg?.windowMs ?? Engine.REPLY_BURST_WINDOW_MS;
+    const { tripped, kept } = replyBurstState(this.replyStamps.get(key) ?? [], Date.now(), max, windowMs);
+    this.replyStamps.set(key, kept);
+    if (!tripped) return;
+    this.replyStamps.delete(key);
+    const issue = await this.store.findIssue(ref.trackerType, scopeKey, ref.issueId);
+    if (!issue) return;
+    const sessions = await this.store.getSessionsForIssue(issue.id);
+    const killed: string[] = [];
+    for (const session of sessions) {
+      const k = this.sessionKey(session, issue);
+      if (!this.running.has(k)) continue;
+      const ok = await this.killSessionProcess(session, k);
+      if (ok) killed.push(session.name);
+    }
+    if (killed.length === 0) return; // burst authored elsewhere (another daemon) — nothing to kill here
+    log.warn(`engine: reply-burst breaker tripped for ${key} (${max} replies in ${Math.round(windowMs / 1000)}s) — killed ${killed.join(", ")}`);
+    await tracker.createComment(ref, `[system] ⚠️ Reply-burst circuit breaker: ${max} replies within ${Math.round(windowMs / 60000)} min — stopped ${killed.length > 1 ? `${killed.length} sessions` : `session **${killed[0]}**`}. Post a comment to wake it again.`).catch((err) => log.error(`engine: burst notice failed for ${key}:`, (err as Error).message));
+  }
+
   private groupConfigFor(issue: Issue): GroupConfig | undefined {
     return this.groupConfigs.get(`${issue.trackerType}:${issue.trackerScopeKey}#${issue.trackerIssueId}`);
   }
@@ -1025,6 +1093,7 @@ export class Engine {
     scopeKey: string,
     tracker: IssueTracker
   ) {
+    this.replyStamps.delete(`${ref.trackerType}:${scopeKey}#${ref.issueId}`);
     const issue = await this.store.findIssue(ref.trackerType, scopeKey, ref.issueId);
     if (!issue) return;
     if (issue.state === "closed") return;
@@ -1074,6 +1143,7 @@ export class Engine {
     scopeKey: string,
     tracker: IssueTracker
   ) {
+    this.replyStamps.delete(`${ref.trackerType}:${scopeKey}#${ref.issueId}`);
     const issue = await this.store.findIssue(ref.trackerType, scopeKey, ref.issueId);
     if (!issue) return;
     this.stopObserver(issue.id);