ework-daemon 0.4.24 → 0.4.26

package/package.json

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

package/src/config.ts

@@ -36,6 +36,7 @@ export const configSchema = z.object({
   }),
   work: z.object({
     capacity: z.coerce.number().int().positive().default(4),
+    maxConcurrent: z.coerce.number().int().positive().default(4),
     heartbeatMs: z.coerce.number().int().positive().default(10_000),
     leaseTtlMs: z.coerce.number().int().positive().default(60_000),
   }),
@@ -85,8 +86,10 @@ const TEST_DEFAULTS = {
 };
 
 function readWorkSection() {
+  const capacity = process.env.WORK_DAEMON_CAPACITY ? Number(process.env.WORK_DAEMON_CAPACITY) : 4;
   return {
-    capacity: process.env.WORK_DAEMON_CAPACITY ? Number(process.env.WORK_DAEMON_CAPACITY) : 4,
+    capacity,
+    maxConcurrent: process.env.WORK_MAX_CONCURRENT ? Number(process.env.WORK_MAX_CONCURRENT) : capacity,
     heartbeatMs: process.env.WORK_DAEMON_HEARTBEAT_MS ? Number(process.env.WORK_DAEMON_HEARTBEAT_MS) : 10_000,
     leaseTtlMs: process.env.WORK_DAEMON_LEASE_TTL_MS ? Number(process.env.WORK_DAEMON_LEASE_TTL_MS) : 60_000,
   };

package/src/op.ts

@@ -299,6 +299,14 @@ export class Store {
     return row ? rowToMessage(row) : undefined;
   }
 
+  async getGlobalPendingMessages(limit: number): Promise<Message[]> {
+    const rows = await getDB().all<MessageRow>(
+      "SELECT * FROM {{messages}} WHERE status = 'pending' ORDER BY created_at ASC LIMIT ?",
+      [limit]
+    );
+    return rows.map(rowToMessage);
+  }
+
   async updateMessageStatus(id: string, status: Message["status"], error?: string): Promise<void> {
     const row = await getDB().get<MessageRow>("SELECT * FROM {{messages}} WHERE uid = ?", [id]);
     const attempts = row ? row.attempts + (status === "failed" ? 1 : 0) : 0;

package/src/opencode.ts

@@ -889,6 +889,11 @@ export class Engine {
       return;
     }
 
+    if (this.running.size >= this.cfg.work.maxConcurrent) {
+      log.info(`engine: concurrency limit reached (${this.running.size}/${this.cfg.work.maxConcurrent}), message ${msg.id.slice(0, 8)} queued for ${k}`);
+      return;
+    }
+
     // Not running — execute directly
     await this.executeMessage(k, session, issue, msg);
   }
@@ -1267,13 +1272,38 @@ export class Engine {
     if (nextMsg) {
       const current = await this.store.getSession(session.id);
       if (current && current.state !== "idle") {
-        await this.dequeueOrIdle(k, current, issue, nextMsg);
-        return;
+        if (this.running.size >= this.cfg.work.maxConcurrent) {
+          log.info(`engine: concurrency limit (${this.running.size}/${this.cfg.work.maxConcurrent}), keeping msg ${nextMsg.id.slice(0, 8)} pending for ${k}`);
+        } else {
+          await this.dequeueOrIdle(k, current, issue, nextMsg);
+          return;
+        }
       }
     }
 
     this.clearRuntimeState(k);
     await this.store.updateSession(session.id, { state: "idle" });
+
+    void this.drainGlobalPending();
+  }
+
+  private async drainGlobalPending(): Promise<void> {
+    const slotsAvailable = this.cfg.work.maxConcurrent - this.running.size;
+    if (slotsAvailable <= 0) return;
+    const pending = await this.store.getGlobalPendingMessages(slotsAvailable);
+    for (const msg of pending) {
+      if (this.running.size >= this.cfg.work.maxConcurrent) break;
+      const session = await this.store.getSession(msg.sessionId);
+      if (!session || session.state === "running") continue;
+      const issue = await this.store.getIssue(session.issueId);
+      if (!issue || issue.state === "closed") continue;
+      const k = this.sessionKey(session, issue);
+      if (this.running.has(k)) continue;
+      const won = await this.store.claimMessage(msg.id);
+      if (!won) continue;
+      log.info(`engine: drainGlobalPending picked up msg ${msg.id.slice(0, 8)} for ${k}`);
+      await this.dequeueOrIdle(k, session, issue, msg);
+    }
   }
 
   private async dequeueOrIdle(k: string, session: OpSession, issue: Issue, msg: Message) {