@trevonistrevon/pi-loop 0.4.8 → 0.4.10

package/dist/index.js

@@ -183,6 +183,7 @@ export default function (pi) {
         if (nativeTaskStore) {
             nativeTaskStore.sweepCompleted();
             widget.update();
+            await cleanupTaskBacklogLoops();
         }
     }
     let agentRunning = false;
@@ -378,6 +379,7 @@ export default function (pi) {
         _latestCtx = ctx;
         widget.setUICtx(ctx.ui);
         await flushPendingNotifications({ ignorePendingMessages: true });
+        await cleanupTaskBacklogLoops();
         await pumpLoops();
     });
     pi.on("session_shutdown", async () => {
@@ -468,6 +470,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
 - **prompt**: what to do when the loop fires (e.g., "check if the build passed")
 - **recurring**: repeat or fire once (default: true)
 - **autoTask**: when pi-tasks is loaded or native task fallback is active, auto-create a task on each fire
+- **taskBacklog**: mark this as a task-backlog worker loop so it auto-deletes when pending tasks reach zero
 - **readOnly**: restrict the agent to read-only tools when this loop fires (default: false)
 - **maxFires**: auto-stop after N fires — prevents infinite token burn on polling loops`,
         promptGuidelines: [
@@ -487,6 +490,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
             "## Task-driven workflows",
             "Do not rely on a past 'tasks:created' event to replay. If tasks already exist, bootstrap the first pass in the current turn or use a hybrid/event loop that can catch future task creation and a cron safety-net.",
             "Use autoTask only when you want the loop itself to create a task on each fire. For processing an existing task backlog, leave autoTask off and have the loop run TaskList to pick the next pending task.",
+            "Set taskBacklog: true for task-worker loops that process the existing pending queue. Task-backlog loops bootstrap against existing pending tasks and auto-delete when the queue reaches zero.",
             "When no tasks are pending, the loop should stop itself or skip the wake entirely — no tokens burned on empty polls.",
             "After creating a loop, tell the user the loop ID so they can cancel it with LoopDelete.",
         ],
@@ -495,13 +499,14 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
             prompt: Type.String({ description: "Prompt to run when the loop fires" }),
             recurring: Type.Optional(Type.Boolean({ description: "Whether loop repeats (default: true)", default: true })),
             autoTask: Type.Optional(Type.Boolean({ description: "Auto-create pi-tasks task on fire", default: false })),
+            taskBacklog: Type.Optional(Type.Boolean({ description: "Mark as a task-backlog worker loop that auto-deletes when pending tasks reach zero", default: false })),
             triggerType: Type.Optional(Type.String({ description: "cron, event, or hybrid (inferred from trigger string if omitted)", enum: ["cron", "event", "hybrid"] })),
             debounceMs: Type.Optional(Type.Number({ description: "Debounce for hybrid triggers (default: 30000)", default: 30000 })),
             readOnly: Type.Optional(Type.Boolean({ description: "Restrict the agent to read-only tools when this loop fires (default: false)", default: false })),
             maxFires: Type.Optional(Type.Number({ description: "Auto-stop after N fires. Prevents infinite token burn on polling loops." })),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            const { trigger: triggerInput, prompt, recurring, autoTask, triggerType, debounceMs, readOnly, maxFires } = params;
+            const { trigger: triggerInput, prompt, recurring, autoTask, taskBacklog, triggerType, debounceMs, readOnly, maxFires } = params;
             let trigger;
             const inferred = triggerType ?? inferTriggerType(triggerInput);
             if (inferred === "cron") {
@@ -528,6 +533,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
             const entry = store.create(trigger, prompt, {
                 recurring: recurring ?? (inferred !== "event"),
                 autoTask,
+                taskBacklog,
                 readOnly,
                 maxFires,
             });
@@ -558,17 +564,31 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
                 `Trigger: ${triggerDesc}\n` +
                 `Recurring: ${entry.recurring}\n` +
                 (entry.autoTask ? `Auto-task: enabled\n` : "") +
+                (entry.taskBacklog ? `Task-backlog: enabled\n` : "") +
                 (bootstrapped ? "Bootstrap: queued initial wake for existing pending tasks\n" : "") +
                 ((tasksAvailable || nativeTasksRegistered) ? "" : "(task system not ready yet — autoTask may not fire until native fallback or pi-tasks becomes available)\n") +
                 `ID: ${entry.id} (use LoopDelete to cancel)`));
         },
     });
     function handleMonitorDoneLoop(doneLoop, monitorId) {
-        triggerSystem.add(doneLoop);
+        const deliver = () => {
+            const current = store.get(doneLoop.id);
+            if (!current)
+                return;
+            debug(`onDone loop #${doneLoop.id} — monitor #${monitorId} completed, delivering directly`);
+            onLoopFire(current);
+            store.delete(doneLoop.id);
+        };
+        const registered = monitorManager.onComplete(monitorId, deliver);
+        if (registered)
+            return;
         const monitor = monitorManager.get(monitorId);
         if (monitor && monitor.status !== "running") {
+            if (monitor.status === "completed") {
+                deliver();
+                return;
+            }
             debug(`onDone loop #${doneLoop.id} — monitor #${monitorId} already ${monitor.status}, expiring`);
-            triggerSystem.remove(doneLoop.id);
             store.delete(doneLoop.id);
         }
     }
@@ -930,10 +950,33 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
     }
     const AUTO_TASK_WORKER_THRESHOLD = 5;
     const AUTO_TASK_WORKER_PROMPT = "Run TaskList, pick next pending task, mark it in_progress, implement it, run validation, complete it. If no pending tasks remain, call LoopDelete on your own loop ID.";
-    function findAutoTaskWorkerLoop() {
-        return store.list().find(entry => entry.status === "active"
+    function isAutoTaskWorkerLoop(entry) {
+        return entry.status === "active"
             && entry.prompt === AUTO_TASK_WORKER_PROMPT
-            && triggerHasEventSource(entry.trigger, "tasks:created"));
+            && triggerHasEventSource(entry.trigger, "tasks:created");
+    }
+    function isTaskBacklogLoop(entry) {
+        return entry.status === "active"
+            && triggerHasEventSource(entry.trigger, "tasks:created")
+            && (entry.taskBacklog === true || isAutoTaskWorkerLoop(entry));
+    }
+    function findAutoTaskWorkerLoop() {
+        return store.list().find(isAutoTaskWorkerLoop);
+    }
+    async function cleanupTaskBacklogLoops() {
+        const backlogLoops = store.list().filter(isTaskBacklogLoop);
+        if (backlogLoops.length === 0)
+            return 0;
+        const pending = await hasPendingTasks();
+        if (pending < 0 || pending > 0)
+            return 0;
+        for (const entry of backlogLoops) {
+            debug(`task backlog loop #${entry.id} — no pending tasks remain, deleting`);
+            triggerSystem.remove(entry.id);
+            store.delete(entry.id);
+        }
+        widget.update();
+        return backlogLoops.length;
     }
     async function ensureAutoTaskWorkerLoop(taskStore) {
         if (taskStore.pendingCount() < AUTO_TASK_WORKER_THRESHOLD)
@@ -949,6 +992,7 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
         };
         const entry = store.create(trigger, AUTO_TASK_WORKER_PROMPT, {
             recurring: true,
+            taskBacklog: true,
             maxFires: 30,
         });
         triggerSystem.add(entry);
@@ -1037,6 +1081,7 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
             ui.notify(`Task #${task.id} reopened`, "info");
         }
         widget.update();
+        await cleanupTaskBacklogLoops();
         return viewNativeTasks(ui);
     }
     // ── Native task tools (only when pi-tasks is absent) ──
@@ -1149,7 +1194,7 @@ Parameters: id (required), status, subject, description`,
                 subject: Type.Optional(Type.String({ description: "New title" })),
                 description: Type.Optional(Type.String({ description: "New description" })),
             }),
-            execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
                 const { id, status, subject, description } = params;
                 const entry = taskStore.update(id, {
                     status: status,
@@ -1159,6 +1204,7 @@ Parameters: id (required), status, subject, description`,
                 if (!entry)
                     return Promise.resolve(textResult(`Task #${id} not found`));
                 widget.update();
+                await cleanupTaskBacklogLoops();
                 const statusMsg = status ? ` → ${status}` : "";
                 return Promise.resolve(textResult(`Task #${id} updated${statusMsg}`));
             },
@@ -1170,11 +1216,13 @@ Parameters: id (required), status, subject, description`,
             parameters: Type.Object({
                 id: Type.String({ description: "Task ID to delete" }),
             }),
-            execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
                 const deleted = taskStore.delete(params.id);
                 widget.update();
-                if (deleted)
+                if (deleted) {
+                    await cleanupTaskBacklogLoops();
                     return Promise.resolve(textResult(`Task #${params.id} deleted`));
+                }
                 return Promise.resolve(textResult(`Task #${params.id} not found`));
             },
         });

package/dist/monitor-manager.d.ts

@@ -9,5 +9,6 @@ export declare class MonitorManager {
     get(id: string): MonitorEntry | undefined;
     list(): MonitorEntry[];
     stop(id: string): Promise<boolean>;
+    onComplete(id: string, callback: () => void): boolean;
     getProcess(id: string): MonitorProcess | undefined;
 }

package/dist/monitor-manager.js

@@ -30,6 +30,7 @@ export class MonitorManager {
             proc: child,
             abortController,
             waiters: [],
+            completionCallbacks: [],
         };
         child.stdout?.on("data", (data) => {
             const lines = data.toString().split("\n");
@@ -70,6 +71,11 @@ export class MonitorManager {
                 exitCode: code,
                 outputLines: entry.outputLines,
             });
+            if (status === "completed") {
+                for (const callback of bp.completionCallbacks)
+                    callback();
+            }
+            bp.completionCallbacks = [];
             for (const resolve of bp.waiters)
                 resolve();
             bp.waiters = [];
@@ -90,6 +96,7 @@ export class MonitorManager {
                     monitorId: id,
                     error: err.message,
                 });
+                bp.completionCallbacks = [];
                 for (const resolve of bp.waiters)
                     resolve();
                 bp.waiters = [];
@@ -134,11 +141,25 @@ export class MonitorManager {
             });
         });
         bp.entry.completedAt = Date.now();
+        bp.completionCallbacks = [];
         for (const resolve of bp.waiters)
             resolve();
         bp.waiters = [];
         return true;
     }
+    onComplete(id, callback) {
+        const bp = this.processes.get(id);
+        if (!bp)
+            return false;
+        if (bp.entry.status === "completed") {
+            callback();
+            return true;
+        }
+        if (bp.entry.status !== "running")
+            return false;
+        bp.completionCallbacks.push(callback);
+        return true;
+    }
     getProcess(id) {
         return this.processes.get(id);
     }

package/dist/store.d.ts

@@ -11,6 +11,7 @@ export declare class LoopStore {
     create(trigger: Trigger, prompt: string, opts: {
         recurring: boolean;
         autoTask?: boolean;
+        taskBacklog?: boolean;
         readOnly?: boolean;
         maxFires?: number;
     }): LoopEntry;

package/dist/store.js

@@ -117,6 +117,7 @@ export class LoopStore {
                 status: "active",
                 recurring: opts.recurring,
                 autoTask: opts.autoTask,
+                taskBacklog: opts.taskBacklog,
                 readOnly: opts.readOnly,
                 maxFires: opts.maxFires,
                 fireCount: 0,

package/dist/types.d.ts

@@ -28,6 +28,7 @@ export interface LoopEntry {
     updatedAt: number;
     expiresAt: number;
     autoTask?: boolean;
+    taskBacklog?: boolean;
     readOnly?: boolean;
     maxFires?: number;
     fireCount?: number;
@@ -54,4 +55,5 @@ export interface MonitorProcess {
     proc: import("node:child_process").ChildProcess;
     abortController: AbortController;
     waiters: Array<() => void>;
+    completionCallbacks: Array<() => void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trevonistrevon/pi-loop",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "description": "A pi extension for cron/event-based agent re-wake loops and background process monitoring.",
   "author": "trevonistrevon",
   "license": "MIT",

package/src/index.ts

@@ -196,6 +196,7 @@ export default function (pi: ExtensionAPI) {
     if (nativeTaskStore) {
       nativeTaskStore.sweepCompleted();
       widget.update();
+      await cleanupTaskBacklogLoops();
     }
   }
 
@@ -410,6 +411,7 @@ export default function (pi: ExtensionAPI) {
     _latestCtx = ctx;
     widget.setUICtx(ctx.ui);
     await flushPendingNotifications({ ignorePendingMessages: true });
+    await cleanupTaskBacklogLoops();
     await pumpLoops();
   });
 
@@ -508,6 +510,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
 - **prompt**: what to do when the loop fires (e.g., "check if the build passed")
 - **recurring**: repeat or fire once (default: true)
 - **autoTask**: when pi-tasks is loaded or native task fallback is active, auto-create a task on each fire
+- **taskBacklog**: mark this as a task-backlog worker loop so it auto-deletes when pending tasks reach zero
 - **readOnly**: restrict the agent to read-only tools when this loop fires (default: false)
 - **maxFires**: auto-stop after N fires — prevents infinite token burn on polling loops`,
     promptGuidelines: [
@@ -527,6 +530,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
       "## Task-driven workflows",
       "Do not rely on a past 'tasks:created' event to replay. If tasks already exist, bootstrap the first pass in the current turn or use a hybrid/event loop that can catch future task creation and a cron safety-net.",
       "Use autoTask only when you want the loop itself to create a task on each fire. For processing an existing task backlog, leave autoTask off and have the loop run TaskList to pick the next pending task.",
+      "Set taskBacklog: true for task-worker loops that process the existing pending queue. Task-backlog loops bootstrap against existing pending tasks and auto-delete when the queue reaches zero.",
       "When no tasks are pending, the loop should stop itself or skip the wake entirely — no tokens burned on empty polls.",
       "After creating a loop, tell the user the loop ID so they can cancel it with LoopDelete.",
     ],
@@ -535,6 +539,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
       prompt: Type.String({ description: "Prompt to run when the loop fires" }),
       recurring: Type.Optional(Type.Boolean({ description: "Whether loop repeats (default: true)", default: true })),
       autoTask: Type.Optional(Type.Boolean({ description: "Auto-create pi-tasks task on fire", default: false })),
+      taskBacklog: Type.Optional(Type.Boolean({ description: "Mark as a task-backlog worker loop that auto-deletes when pending tasks reach zero", default: false })),
       triggerType: Type.Optional(Type.String({ description: "cron, event, or hybrid (inferred from trigger string if omitted)", enum: ["cron", "event", "hybrid"] })),
       debounceMs: Type.Optional(Type.Number({ description: "Debounce for hybrid triggers (default: 30000)", default: 30000 })),
       readOnly: Type.Optional(Type.Boolean({ description: "Restrict the agent to read-only tools when this loop fires (default: false)", default: false })),
@@ -542,7 +547,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
     }),
 
     async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-      const { trigger: triggerInput, prompt, recurring, autoTask, triggerType, debounceMs, readOnly, maxFires } = params;
+      const { trigger: triggerInput, prompt, recurring, autoTask, taskBacklog, triggerType, debounceMs, readOnly, maxFires } = params;
 
       let trigger: Trigger;
       const inferred = triggerType ?? inferTriggerType(triggerInput);
@@ -570,6 +575,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
       const entry = store.create(trigger, prompt, {
         recurring: recurring ?? (inferred !== "event"),
         autoTask,
+        taskBacklog,
         readOnly,
         maxFires,
       });
@@ -606,6 +612,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
         `Trigger: ${triggerDesc}\n` +
         `Recurring: ${entry.recurring}\n` +
         (entry.autoTask ? `Auto-task: enabled\n` : "") +
+        (entry.taskBacklog ? `Task-backlog: enabled\n` : "") +
         (bootstrapped ? "Bootstrap: queued initial wake for existing pending tasks\n" : "") +
         ((tasksAvailable || nativeTasksRegistered) ? "" : "(task system not ready yet — autoTask may not fire until native fallback or pi-tasks becomes available)\n") +
         `ID: ${entry.id} (use LoopDelete to cancel)`
@@ -614,11 +621,24 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
   });
 
   function handleMonitorDoneLoop(doneLoop: LoopEntry, monitorId: string): void {
-    triggerSystem.add(doneLoop);
+    const deliver = () => {
+      const current = store.get(doneLoop.id);
+      if (!current) return;
+      debug(`onDone loop #${doneLoop.id} — monitor #${monitorId} completed, delivering directly`);
+      onLoopFire(current);
+      store.delete(doneLoop.id);
+    };
+
+    const registered = monitorManager.onComplete(monitorId, deliver);
+    if (registered) return;
+
     const monitor = monitorManager.get(monitorId);
     if (monitor && monitor.status !== "running") {
+      if (monitor.status === "completed") {
+        deliver();
+        return;
+      }
       debug(`onDone loop #${doneLoop.id} — monitor #${monitorId} already ${monitor.status}, expiring`);
-      triggerSystem.remove(doneLoop.id);
       store.delete(doneLoop.id);
     }
   }
@@ -1009,12 +1029,36 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
   const AUTO_TASK_WORKER_THRESHOLD = 5;
   const AUTO_TASK_WORKER_PROMPT = "Run TaskList, pick next pending task, mark it in_progress, implement it, run validation, complete it. If no pending tasks remain, call LoopDelete on your own loop ID.";
 
-  function findAutoTaskWorkerLoop(): LoopEntry | undefined {
-    return store.list().find(entry =>
-      entry.status === "active"
+  function isAutoTaskWorkerLoop(entry: LoopEntry): boolean {
+    return entry.status === "active"
       && entry.prompt === AUTO_TASK_WORKER_PROMPT
+      && triggerHasEventSource(entry.trigger, "tasks:created");
+  }
+
+  function isTaskBacklogLoop(entry: LoopEntry): boolean {
+    return entry.status === "active"
       && triggerHasEventSource(entry.trigger, "tasks:created")
-    );
+      && (entry.taskBacklog === true || isAutoTaskWorkerLoop(entry));
+  }
+
+  function findAutoTaskWorkerLoop(): LoopEntry | undefined {
+    return store.list().find(isAutoTaskWorkerLoop);
+  }
+
+  async function cleanupTaskBacklogLoops(): Promise<number> {
+    const backlogLoops = store.list().filter(isTaskBacklogLoop);
+    if (backlogLoops.length === 0) return 0;
+
+    const pending = await hasPendingTasks();
+    if (pending < 0 || pending > 0) return 0;
+
+    for (const entry of backlogLoops) {
+      debug(`task backlog loop #${entry.id} — no pending tasks remain, deleting`);
+      triggerSystem.remove(entry.id);
+      store.delete(entry.id);
+    }
+    widget.update();
+    return backlogLoops.length;
   }
 
   async function ensureAutoTaskWorkerLoop(taskStore: TaskStore): Promise<{ entry?: LoopEntry; created: boolean }> {
@@ -1031,6 +1075,7 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
     };
     const entry = store.create(trigger, AUTO_TASK_WORKER_PROMPT, {
       recurring: true,
+      taskBacklog: true,
       maxFires: 30,
     });
     triggerSystem.add(entry);
@@ -1120,6 +1165,7 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
     }
 
     widget.update();
+    await cleanupTaskBacklogLoops();
     return viewNativeTasks(ui);
   }
 
@@ -1238,7 +1284,7 @@ Parameters: id (required), status, subject, description`,
         subject: Type.Optional(Type.String({ description: "New title" })),
         description: Type.Optional(Type.String({ description: "New description" })),
       }),
-      execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
         const { id, status, subject, description } = params;
         const entry = taskStore.update(id, {
           status: status as "pending" | "in_progress" | "completed" | undefined,
@@ -1247,6 +1293,7 @@ Parameters: id (required), status, subject, description`,
         });
         if (!entry) return Promise.resolve(textResult(`Task #${id} not found`));
         widget.update();
+        await cleanupTaskBacklogLoops();
         const statusMsg = status ? ` → ${status}` : "";
         return Promise.resolve(textResult(`Task #${id} updated${statusMsg}`));
       },
@@ -1259,10 +1306,13 @@ Parameters: id (required), status, subject, description`,
       parameters: Type.Object({
         id: Type.String({ description: "Task ID to delete" }),
       }),
-      execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
         const deleted = taskStore.delete(params.id);
         widget.update();
-        if (deleted) return Promise.resolve(textResult(`Task #${params.id} deleted`));
+        if (deleted) {
+          await cleanupTaskBacklogLoops();
+          return Promise.resolve(textResult(`Task #${params.id} deleted`));
+        }
         return Promise.resolve(textResult(`Task #${params.id} not found`));
       },
     });

package/src/monitor-manager.ts

@@ -35,6 +35,7 @@ export class MonitorManager {
       proc: child,
       abortController,
       waiters: [],
+      completionCallbacks: [],
     };
 
     child.stdout?.on("data", (data: Buffer) => {
@@ -74,6 +75,10 @@ export class MonitorManager {
         exitCode: code,
         outputLines: entry.outputLines,
       });
+      if (status === "completed") {
+        for (const callback of bp.completionCallbacks) callback();
+      }
+      bp.completionCallbacks = [];
       for (const resolve of bp.waiters) resolve();
       bp.waiters = [];
       // Remove completed/errored monitors after a brief delay so tool
@@ -95,6 +100,7 @@ export class MonitorManager {
           monitorId: id,
           error: err.message,
         });
+        bp.completionCallbacks = [];
         for (const resolve of bp.waiters) resolve();
         bp.waiters = [];
       }
@@ -143,11 +149,24 @@ export class MonitorManager {
     });
 
     bp.entry.completedAt = Date.now();
+    bp.completionCallbacks = [];
     for (const resolve of bp.waiters) resolve();
     bp.waiters = [];
     return true;
   }
 
+  onComplete(id: string, callback: () => void): boolean {
+    const bp = this.processes.get(id);
+    if (!bp) return false;
+    if (bp.entry.status === "completed") {
+      callback();
+      return true;
+    }
+    if (bp.entry.status !== "running") return false;
+    bp.completionCallbacks.push(callback);
+    return true;
+  }
+
   getProcess(id: string): MonitorProcess | undefined {
     return this.processes.get(id);
   }

package/src/store.ts

@@ -95,7 +95,7 @@ export class LoopStore {
     }
   }
 
-  create(trigger: Trigger, prompt: string, opts: { recurring: boolean; autoTask?: boolean; readOnly?: boolean; maxFires?: number }): LoopEntry {
+  create(trigger: Trigger, prompt: string, opts: { recurring: boolean; autoTask?: boolean; taskBacklog?: boolean; readOnly?: boolean; maxFires?: number }): LoopEntry {
     return this.withLock(() => {
       if (this.loops.size >= MAX_LOOPS) {
         throw new Error(`Maximum of ${MAX_LOOPS} loops reached. Delete some before creating new ones.`);
@@ -108,6 +108,7 @@ export class LoopStore {
         status: "active",
         recurring: opts.recurring,
         autoTask: opts.autoTask,
+        taskBacklog: opts.taskBacklog,
         readOnly: opts.readOnly,
         maxFires: opts.maxFires,
         fireCount: 0,

package/src/types.ts

@@ -30,6 +30,7 @@ export interface LoopEntry {
   updatedAt: number;
   expiresAt: number;
   autoTask?: boolean;
+  taskBacklog?: boolean;
   readOnly?: boolean;
   maxFires?: number;
   fireCount?: number;
@@ -59,4 +60,5 @@ export interface MonitorProcess {
   proc: import("node:child_process").ChildProcess;
   abortController: AbortController;
   waiters: Array<() => void>;
+  completionCallbacks: Array<() => void>;
 }