@iletai/nzb 1.7.3 → 1.8.0

package/dist/copilot/tools.js

@@ -4,9 +4,13 @@ import { homedir } from "os";
 import { join, resolve, sep } from "path";
 import { z } from "zod";
 import { config, persistModel } from "../config.js";
+import { scheduleJob, triggerJob, unscheduleJob, getSchedulerStatus } from "../cron/scheduler.js";
 import { SESSIONS_DIR } from "../paths.js";
 import { getDb } from "../store/db.js";
+import { createCronJob, deleteCronJob, getCronJob, getRecentRuns, updateCronJob, } from "../store/cron-store.js";
+import { withTimeout } from "../utils.js";
 import { addMemory, removeMemory, searchMemories } from "../store/memory.js";
+import { getFailoverManager } from "./orchestrator.js";
 import { createSkill, listSkills, removeSkill } from "./skills.js";
 function isTimeoutError(err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -111,7 +115,9 @@ export function createTools(deps) {
                     })
                         .finally(() => {
                         // Auto-destroy background workers after completion to free memory (~400MB per worker)
-                        session.disconnect().catch(() => { });
+                        withTimeout(session.disconnect(), 5_000, `worker '${args.name}' disconnect`).catch((err) => {
+                            console.error(`[nzb] Worker '${args.name}' disconnect timeout/error:`, err instanceof Error ? err.message : err);
+                        });
                         deps.workers.delete(args.name);
                         try {
                             getDb().prepare(`DELETE FROM worker_sessions WHERE name = ?`).run(args.name);
@@ -162,7 +168,9 @@ export function createTools(deps) {
                 })
                     .finally(() => {
                     // Auto-destroy after each send_to_worker dispatch to free memory
-                    worker.session.disconnect().catch(() => { });
+                    withTimeout(worker.session.disconnect(), 5_000, `worker '${args.name}' disconnect`).catch((err) => {
+                        console.error(`[nzb] Worker '${args.name}' disconnect timeout/error:`, err instanceof Error ? err.message : err);
+                    });
                     deps.workers.delete(args.name);
                     try {
                         getDb().prepare(`DELETE FROM worker_sessions WHERE name = ?`).run(args.name);
@@ -210,10 +218,10 @@ export function createTools(deps) {
                     return `No worker named '${args.name}'.`;
                 }
                 try {
-                    await worker.session.disconnect();
+                    await withTimeout(worker.session.disconnect(), 5_000, `worker '${args.name}' disconnect`);
                 }
-                catch {
-                    // Session may already be gone
+                catch (err) {
+                    console.error(`[nzb] Worker '${args.name}' disconnect timeout/error:`, err instanceof Error ? err.message : err);
                 }
                 deps.workers.delete(args.name);
                 const db = getDb();
@@ -232,7 +240,9 @@ export function createTools(deps) {
                 if (!worker)
                     return `No worker found with name '${args.name}'.`;
                 try {
-                    worker.session.disconnect().catch(() => { });
+                    withTimeout(worker.session.disconnect(), 5_000, `worker '${args.name}' disconnect`).catch((err) => {
+                        console.error(`[nzb] Worker '${args.name}' disconnect timeout/error:`, err instanceof Error ? err.message : err);
+                    });
                 }
                 catch {
                     // Session may already be destroyed
@@ -347,7 +357,9 @@ export function createTools(deps) {
                             deps.onWorkerComplete(member.name, errMsg);
                         })
                             .finally(() => {
-                            session.disconnect().catch(() => { });
+                            withTimeout(session.disconnect(), 5_000, `worker '${member.name}' disconnect`).catch((err) => {
+                                console.error(`[nzb] Worker '${member.name}' disconnect timeout/error:`, err instanceof Error ? err.message : err);
+                            });
                             deps.workers.delete(member.name);
                             try {
                                 getDb().prepare(`DELETE FROM worker_sessions WHERE name = ?`).run(member.name);
@@ -643,6 +655,27 @@ export function createTools(deps) {
                 }
             },
         }),
+        defineTool("model_health", {
+            description: "Show health status of all models in the failover chain. " +
+                "Displays model name, provider, status (healthy/cooldown/degraded), failure count, and last failure time. " +
+                "Use when the user asks about model health, failover status, or which models are available in the chain.",
+            parameters: z.object({}),
+            handler: async () => {
+                const manager = getFailoverManager();
+                if (!manager || !manager.enabled) {
+                    return (`Model failover is not configured. Current model: ${config.copilotModel}\n\n` +
+                        `To enable failover, set MODEL_FAILOVER_CHAIN in ~/.nzb/.env with a comma-separated list of models.\n` +
+                        `Example: MODEL_FAILOVER_CHAIN=claude-sonnet-4.6,gpt-4.1,gemini-2.0-flash`);
+                }
+                const statuses = manager.getHealthStatus();
+                const lines = statuses.map((s) => {
+                    const icon = s.status === "healthy" ? "✅" : s.status === "cooldown" ? "⏳" : "⚠️";
+                    const lastFail = s.lastFailure ? ` (last fail: ${s.lastFailure})` : "";
+                    return `${icon} ${s.model} [${s.provider}] — ${s.status} | failures: ${s.failures} | successes: ${s.successCount}${lastFail}`;
+                });
+                return `Model Failover Health (active: ${config.copilotModel}):\n${lines.join("\n")}`;
+            },
+        }),
         defineTool("remember", {
             description: "Save something to NZB's long-term memory. Use when the user says 'remember that...', " +
                 "states a preference, shares a fact about themselves, or mentions something important " +
@@ -697,6 +730,111 @@ export function createTools(deps) {
                     : `Memory #${args.memory_id} not found — it may have already been removed.`;
             },
         }),
+        defineTool("manage_cron", {
+            description: "Manage scheduled cron jobs. Use to create, list, remove, enable, disable, or trigger " +
+                "recurring tasks like health checks, backups, notifications, webhook calls, or scheduled prompts.",
+            parameters: z.object({
+                action: z
+                    .enum(["list", "add", "remove", "enable", "disable", "trigger", "history"])
+                    .describe("Action to perform"),
+                job_id: z.string().optional().describe("Job ID (required for remove/enable/disable/trigger/history)"),
+                name: z.string().optional().describe("Job name (required for add)"),
+                cron_expression: z
+                    .string()
+                    .optional()
+                    .describe("Cron expression, e.g. '0 */6 * * *' for every 6 hours (required for add)"),
+                task_type: z
+                    .enum(["prompt", "health_check", "backup", "notification", "webhook"])
+                    .optional()
+                    .describe("Task type (required for add)"),
+                payload: z.string().optional().describe("JSON payload for the task (optional for add)"),
+                notify_telegram: z.boolean().optional().describe("Send result to Telegram (default: true)"),
+            }),
+            handler: async (args) => {
+                try {
+                    switch (args.action) {
+                        case "list": {
+                            const status = getSchedulerStatus();
+                            if (status.length === 0)
+                                return "No cron jobs configured.";
+                            const lines = status.map((j) => `• ${j.id} — ${j.name} [${j.taskType}] ${j.enabled ? "✅" : "⏸️"} ` +
+                                `${j.active ? "active" : "inactive"} | ${j.cronExpression}` +
+                                (j.nextRun ? ` | next: ${j.nextRun}` : ""));
+                            return `${status.length} cron job(s):\n${lines.join("\n")}`;
+                        }
+                        case "add": {
+                            if (!args.job_id || !args.name || !args.cron_expression || !args.task_type) {
+                                return "Missing required fields: job_id, name, cron_expression, task_type";
+                            }
+                            const job = createCronJob({
+                                id: args.job_id,
+                                name: args.name,
+                                cronExpression: args.cron_expression,
+                                taskType: args.task_type,
+                                payload: args.payload,
+                                notifyTelegram: args.notify_telegram,
+                            });
+                            if (job.enabled)
+                                scheduleJob(job);
+                            return `Cron job '${job.id}' (${job.name}) created and scheduled: ${job.cronExpression}`;
+                        }
+                        case "remove": {
+                            if (!args.job_id)
+                                return "Missing job_id";
+                            unscheduleJob(args.job_id);
+                            const deleted = deleteCronJob(args.job_id);
+                            return deleted
+                                ? `Cron job '${args.job_id}' deleted.`
+                                : `Job '${args.job_id}' not found.`;
+                        }
+                        case "enable": {
+                            if (!args.job_id)
+                                return "Missing job_id";
+                            const enabled = updateCronJob(args.job_id, { enabled: true });
+                            if (!enabled)
+                                return `Job '${args.job_id}' not found.`;
+                            scheduleJob(enabled);
+                            return `Cron job '${args.job_id}' enabled and scheduled.`;
+                        }
+                        case "disable": {
+                            if (!args.job_id)
+                                return "Missing job_id";
+                            const disabled = updateCronJob(args.job_id, { enabled: false });
+                            if (!disabled)
+                                return `Job '${args.job_id}' not found.`;
+                            unscheduleJob(args.job_id);
+                            return `Cron job '${args.job_id}' disabled.`;
+                        }
+                        case "trigger": {
+                            if (!args.job_id)
+                                return "Missing job_id";
+                            const result = await triggerJob(args.job_id);
+                            return `Triggered '${args.job_id}':\n${result}`;
+                        }
+                        case "history": {
+                            if (!args.job_id)
+                                return "Missing job_id";
+                            const job = getCronJob(args.job_id);
+                            if (!job)
+                                return `Job '${args.job_id}' not found.`;
+                            const runs = getRecentRuns(args.job_id);
+                            if (runs.length === 0)
+                                return `No runs recorded for '${args.job_id}'.`;
+                            const lines = runs.map((r) => `• ${r.status} at ${r.startedAt}` +
+                                (r.durationMs !== null ? ` (${r.durationMs}ms)` : "") +
+                                (r.error ? ` — ${r.error}` : "") +
+                                (r.result ? ` — ${r.result.slice(0, 100)}` : ""));
+                            return `Recent runs for '${job.name}':\n${lines.join("\n")}`;
+                        }
+                        default:
+                            return `Unknown action: ${args.action}`;
+                    }
+                }
+                catch (err) {
+                    return `Cron error: ${err instanceof Error ? err.message : String(err)}`;
+                }
+            },
+        }),
         defineTool("restart_nzb", {
             description: "Restart the NZB daemon process. Use when the user asks NZB to restart himself, " +
                 "or when a restart is needed to pick up configuration changes. " +

package/dist/cron/scheduler.js

@@ -0,0 +1,159 @@
+import { Cron } from "croner";
+import { getCronJob, listCronJobs, recordCronRun, updateCronJob, } from "../store/cron-store.js";
+import { executeCronTask, notifyResult } from "./task-runner.js";
+const activeTimers = new Map();
+const runningJobs = new Set();
+/** Start the cron scheduler: load all enabled jobs from DB and schedule them. */
+export function startCronScheduler() {
+    const jobs = listCronJobs(true);
+    console.log(`[nzb] Cron scheduler starting with ${jobs.length} enabled job(s)`);
+    for (const job of jobs) {
+        scheduleJob(job);
+    }
+}
+/** Stop the cron scheduler: cancel all active timers. */
+export function stopCronScheduler() {
+    for (const [id, cron] of activeTimers) {
+        cron.stop();
+        console.log(`[nzb] Cron job '${id}' stopped`);
+    }
+    activeTimers.clear();
+    console.log("[nzb] Cron scheduler stopped");
+}
+/** Schedule (or reschedule) a single job. */
+export function scheduleJob(job) {
+    // Unschedule if already active
+    unscheduleJob(job.id);
+    if (!job.enabled)
+        return;
+    try {
+        const cron = new Cron(job.cronExpression, { name: job.id }, () => {
+            void runJob(job.id);
+        });
+        activeTimers.set(job.id, cron);
+        // Update nextRunAt in DB
+        const nextDate = cron.nextRun();
+        if (nextDate) {
+            updateCronJob(job.id, { nextRunAt: nextDate.toISOString() });
+        }
+        console.log(`[nzb] Cron job '${job.id}' (${job.name}) scheduled: ${job.cronExpression}`);
+    }
+    catch (err) {
+        console.error(`[nzb] Failed to schedule cron job '${job.id}':`, err instanceof Error ? err.message : err);
+    }
+}
+/** Unschedule a single job by ID. */
+export function unscheduleJob(jobId) {
+    const existing = activeTimers.get(jobId);
+    if (existing) {
+        existing.stop();
+        activeTimers.delete(jobId);
+    }
+}
+/** Manually trigger a job immediately. */
+export async function triggerJob(jobId) {
+    const job = getCronJob(jobId);
+    if (!job)
+        return `Job '${jobId}' not found.`;
+    return await runJob(jobId);
+}
+/** Get status of all scheduled jobs. */
+export function getSchedulerStatus() {
+    const allJobs = listCronJobs();
+    return allJobs.map((job) => {
+        const timer = activeTimers.get(job.id);
+        const nextRun = timer?.nextRun()?.toISOString() ?? job.nextRunAt;
+        return {
+            id: job.id,
+            name: job.name,
+            cronExpression: job.cronExpression,
+            taskType: job.taskType,
+            enabled: job.enabled,
+            active: activeTimers.has(job.id),
+            nextRun,
+        };
+    });
+}
+/** Internal: execute a job with retry, timeout, recording, and notification. */
+async function runJob(jobId) {
+    if (runningJobs.has(jobId)) {
+        console.log(`[nzb] Cron "${jobId}" already running, skipping`);
+        return `Job '${jobId}' already running.`;
+    }
+    const job = getCronJob(jobId);
+    if (!job)
+        return `Job '${jobId}' not found.`;
+    runningJobs.add(jobId);
+    console.log(`[nzb] Cron job '${job.id}' (${job.name}) executing...`);
+    const startedAt = new Date();
+    let lastError = null;
+    const maxAttempts = job.maxRetries + 1;
+    try {
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                // Apply timeout
+                const result = await withTaskTimeout(executeCronTask(job), job.timeoutMs);
+                // Record success
+                const finishedAt = new Date();
+                recordCronRun(jobId, "success", startedAt, finishedAt, result, null);
+                updateCronJob(jobId, { lastRunAt: finishedAt.toISOString() });
+                // Update nextRunAt
+                const timer = activeTimers.get(jobId);
+                if (timer) {
+                    const nextDate = timer.nextRun();
+                    if (nextDate) {
+                        updateCronJob(jobId, { nextRunAt: nextDate.toISOString() });
+                    }
+                }
+                console.log(`[nzb] Cron job '${job.id}' completed in ${finishedAt.getTime() - startedAt.getTime()}ms`);
+                await notifyResult(job, `✅ Completed\n${result}`);
+                return result;
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err.message : String(err);
+                const isTimeout = lastError.includes("timed out");
+                if (attempt < maxAttempts && !isTimeout) {
+                    console.log(`[nzb] Cron job '${job.id}' attempt ${attempt}/${maxAttempts} failed: ${lastError}. Retrying...`);
+                    // Brief delay before retry
+                    await new Promise((r) => setTimeout(r, 1000 * attempt));
+                    continue;
+                }
+                const finishedAt = new Date();
+                const status = isTimeout ? "timeout" : "error";
+                recordCronRun(jobId, status, startedAt, finishedAt, null, lastError);
+                updateCronJob(jobId, { lastRunAt: finishedAt.toISOString() });
+                // Update nextRunAt even on failure
+                const timer = activeTimers.get(jobId);
+                if (timer) {
+                    const nextDate = timer.nextRun();
+                    if (nextDate) {
+                        updateCronJob(jobId, { nextRunAt: nextDate.toISOString() });
+                    }
+                }
+                console.error(`[nzb] Cron job '${job.id}' failed: ${lastError}`);
+                await notifyResult(job, `❌ Failed: ${lastError}`);
+                return `Error: ${lastError}`;
+            }
+        }
+        return `Error: ${lastError ?? "Unknown error"}`;
+    }
+    finally {
+        runningJobs.delete(jobId);
+    }
+}
+/** Wrap a promise with a timeout. */
+function withTaskTimeout(promise, ms) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new Error(`Task timed out after ${ms}ms`));
+        }, ms);
+        promise.then((v) => {
+            clearTimeout(timer);
+            resolve(v);
+        }, (e) => {
+            clearTimeout(timer);
+            reject(e);
+        });
+    });
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/cron/task-runner.js

@@ -0,0 +1,170 @@
+import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
+import { freemem, totalmem } from "os";
+import { join } from "path";
+import { config } from "../config.js";
+import { DB_PATH, NZB_HOME } from "../paths.js";
+const BACKUPS_DIR = join(NZB_HOME, "backups");
+/** Notify result to Telegram if the job has notifyTelegram enabled. */
+export async function notifyResult(job, message) {
+    if (!job.notifyTelegram || !config.telegramEnabled)
+        return;
+    try {
+        const { sendProactiveMessage } = await import("../telegram/bot.js");
+        await sendProactiveMessage(`⏰ [${job.name}] ${message}`);
+    }
+    catch (err) {
+        console.error("[nzb] Cron notify failed:", err instanceof Error ? err.message : err);
+    }
+}
+/** Execute a cron task based on its taskType. Returns a result string. */
+export async function executeCronTask(job) {
+    const payload = JSON.parse(job.payload);
+    switch (job.taskType) {
+        case "prompt":
+            return await executePromptTask(payload);
+        case "health_check":
+            return await executeHealthCheckTask();
+        case "backup":
+            return await executeBackupTask();
+        case "notification":
+            return await executeNotificationTask(job, payload);
+        case "webhook":
+            return await executeWebhookTask(payload, job.timeoutMs);
+        default:
+            throw new Error(`Unknown task type: ${job.taskType}`);
+    }
+}
+async function executePromptTask(payload) {
+    const prompt = payload.prompt || "Scheduled check-in. Anything to report?";
+    try {
+        const { sendToOrchestrator } = await import("../copilot/orchestrator.js");
+        return await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => reject(new Error("Prompt task timed out after 120s")), 120_000);
+            let fullResponse = "";
+            sendToOrchestrator(`[Scheduled task] ${prompt}`, { type: "background" }, (text, done) => {
+                if (done) {
+                    clearTimeout(timeout);
+                    fullResponse = text;
+                    resolve(fullResponse);
+                }
+            });
+        });
+    }
+    catch (err) {
+        throw new Error(`Prompt task failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+async function executeHealthCheckTask() {
+    const checks = [];
+    // Memory check
+    const free = freemem();
+    const total = totalmem();
+    const usedPct = Math.round(((total - free) / total) * 100);
+    checks.push(`Memory: ${usedPct}% used (${formatBytes(free)} free / ${formatBytes(total)} total)`);
+    // Disk check (database size)
+    try {
+        if (existsSync(DB_PATH)) {
+            const dbSize = statSync(DB_PATH).size;
+            checks.push(`Database: ${formatBytes(dbSize)}`);
+        }
+    }
+    catch {
+        checks.push("Database: unable to check");
+    }
+    // Process uptime
+    const uptimeSeconds = Math.floor(process.uptime());
+    const hours = Math.floor(uptimeSeconds / 3600);
+    const minutes = Math.floor((uptimeSeconds % 3600) / 60);
+    checks.push(`Uptime: ${hours}h ${minutes}m`);
+    // Node.js memory usage
+    const mem = process.memoryUsage();
+    checks.push(`Heap: ${formatBytes(mem.heapUsed)} / ${formatBytes(mem.heapTotal)}`);
+    checks.push(`RSS: ${formatBytes(mem.rss)}`);
+    return checks.join("\n");
+}
+async function executeBackupTask() {
+    mkdirSync(BACKUPS_DIR, { recursive: true });
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const backed = [];
+    // Backup database
+    if (existsSync(DB_PATH)) {
+        const dest = join(BACKUPS_DIR, `nzb-${timestamp}.db`);
+        copyFileSync(DB_PATH, dest);
+        backed.push(`Database → ${dest}`);
+    }
+    // Backup memories (WAL file if exists)
+    const walPath = DB_PATH + "-wal";
+    if (existsSync(walPath)) {
+        const dest = join(BACKUPS_DIR, `nzb-${timestamp}.db-wal`);
+        copyFileSync(walPath, dest);
+        backed.push(`WAL → ${dest}`);
+    }
+    // Prune old backups: keep last 10
+    try {
+        const files = readdirSync(BACKUPS_DIR)
+            .filter((f) => f.startsWith("nzb-") && f.endsWith(".db"))
+            .sort()
+            .reverse();
+        for (const old of files.slice(10)) {
+            const { unlinkSync } = await import("fs");
+            unlinkSync(join(BACKUPS_DIR, old));
+            // Also remove corresponding WAL
+            const walFile = old + "-wal";
+            if (existsSync(join(BACKUPS_DIR, walFile))) {
+                unlinkSync(join(BACKUPS_DIR, walFile));
+            }
+        }
+    }
+    catch {
+        // Prune failure is non-critical
+    }
+    return backed.length > 0 ? `Backup complete:\n${backed.join("\n")}` : "Nothing to backup";
+}
+async function executeNotificationTask(job, payload) {
+    const message = payload.message || "Scheduled notification";
+    if (config.telegramEnabled) {
+        const { sendProactiveMessage } = await import("../telegram/bot.js");
+        await sendProactiveMessage(message);
+        return `Notification sent: ${message}`;
+    }
+    return `Notification skipped (Telegram not configured): ${message}`;
+}
+async function executeWebhookTask(payload, timeoutMs) {
+    const url = payload.url;
+    if (!url)
+        throw new Error("Webhook task requires 'url' in payload");
+    const method = (payload.method || "GET").toUpperCase();
+    const headers = payload.headers || {};
+    const body = payload.body ? JSON.stringify(payload.body) : undefined;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, {
+            method,
+            headers: { "Content-Type": "application/json", ...headers },
+            body: method !== "GET" ? body : undefined,
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        const text = await response.text();
+        const truncated = text.length > 500 ? text.slice(0, 500) + "…" : text;
+        return `Webhook ${method} ${url} → ${response.status} ${response.statusText}\n${truncated}`;
+    }
+    catch (err) {
+        clearTimeout(timer);
+        if (err instanceof Error && err.name === "AbortError") {
+            throw new Error(`Webhook timed out after ${timeoutMs}ms`);
+        }
+        throw err;
+    }
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
+}
+//# sourceMappingURL=task-runner.js.map

package/dist/daemon.js

@@ -7,6 +7,7 @@ import { getWorkers, initOrchestrator, setMessageLogger, setProactiveNotify, set
 import { PID_FILE_PATH } from "./paths.js";
 import { closeDb, getDb } from "./store/db.js";
 import { createBot, sendProactiveMessage, sendWorkerNotification, startBot, stopBot } from "./telegram/bot.js";
+import { startCronScheduler, stopCronScheduler } from "./cron/scheduler.js";
 import { checkForUpdate } from "./update.js";
 // Log the active CA bundle (injected by cli.ts via re-exec).
 if (process.env.NODE_EXTRA_CA_CERTS) {
@@ -134,6 +135,8 @@ async function main() {
     });
     // Start HTTP API for TUI
     await startApiServer();
+    // Start cron scheduler
+    startCronScheduler();
     // Start Telegram bot (if configured)
     if (config.telegramEnabled) {
         createBot();
@@ -194,6 +197,7 @@ async function shutdown() {
     forceTimer.unref();
     // Stop health check timer first
     stopHealthCheck();
+    stopCronScheduler();
     if (config.telegramEnabled) {
         try {
             await stopBot();
@@ -220,6 +224,7 @@ async function shutdown() {
 export async function restartDaemon() {
     console.log("[nzb] Restarting...");
     stopHealthCheck();
+    stopCronScheduler();
     const activeWorkers = getWorkers();
     const runningCount = Array.from(activeWorkers.values()).filter((w) => w.status === "running").length;
     if (runningCount > 0) {