@trevonistrevon/pi-loop 0.4.2 → 0.4.4

package/AGENTS.md

@@ -50,9 +50,13 @@ Three trigger types, all stored as `LoopEntry.trigger`:
 - `{ type: "event", source: "tool_execution_start", filter?: "regex:..." | '{"key":"value"}' }` — eventbus-based
 - `{ type: "hybrid", cron: "...", event: { source, filter? }, debounceMs: 30000 }` — both with debounce
 
+All cron/hybrid loops are dynamic: they track their next fire time but only deliver on agent idle (`agent_end`/`turn_start`) rather than wall-clock timers.
+
 ## Re-wake via In-Memory Pending Notifications
 When a loop fires, the scheduler calls `onLoopFire()` which emits `pi.events("loop:fire", ...)`. The extension buffers a pending notification in memory, re-checks whether the wake is still relevant, and only then injects a `pi.sendMessage()` custom message to wake the agent. Do not rely on early queued follow-up user messages for loop delivery; those are not extension-cancelable once handed to pi's queue.
 
+All loops are idle-driven. Cron and hybrid loops track their next fire time but only deliver when the agent becomes idle (via `agent_end`/`turn_start`), resetting their timer from the actual delivery point.
+
 ## Monitor Streaming via PI Events
 Monitor stdout/stderr lines are emitted as `pi.events("monitor:output", { monitorId, line, timestamp })`. Tool consumers subscribe to these events. Completion emits `"monitor:done"` / `"monitor:error"`.
 

package/dist/index.js

@@ -209,6 +209,35 @@ export default function (pi) {
             message: buildLoopFireMessage(data),
         };
     }
+    function triggerHasEventSource(trigger, source) {
+        if (typeof trigger === "string")
+            return false;
+        return trigger.type === "event"
+            ? trigger.source === source
+            : trigger.type === "hybrid"
+                ? trigger.event.source === source
+                : false;
+    }
+    async function maybeBootstrapTaskLoop(entry) {
+        if (!entry.recurring)
+            return false;
+        if (!triggerHasEventSource(entry.trigger, "tasks:created"))
+            return false;
+        const pending = await hasPendingTasks();
+        if (pending <= 0)
+            return false;
+        debug(`loop #${entry.id} — bootstrapping existing pending tasks (${pending})`);
+        await queueOrDeliverNotification({
+            loopId: entry.id,
+            prompt: entry.prompt,
+            trigger: entry.trigger,
+            timestamp: Date.now(),
+            readOnly: entry.readOnly,
+            recurring: false,
+            autoTask: true,
+        });
+        return true;
+    }
     async function deliverNotification(notification) {
         if (notification.autoTask) {
             const pending = await hasPendingTasks();
@@ -321,6 +350,7 @@ export default function (pi) {
         widget.setUICtx(ctx.ui);
         upgradeStoreIfNeeded(ctx);
         widget.update();
+        await pumpLoops();
     });
     pi.on("before_agent_start", async (_event, ctx) => {
         _latestCtx = ctx;
@@ -339,6 +369,7 @@ export default function (pi) {
         _latestCtx = ctx;
         widget.setUICtx(ctx.ui);
         await flushPendingNotifications();
+        await pumpLoops();
     });
     pi.on("session_shutdown", async () => {
         agentRunning = false;
@@ -360,6 +391,25 @@ export default function (pi) {
         showPersistedLoops(isResume);
         widget.update();
     });
+    // ── Dynamic loop pump — fires cron/hybrid loops on idle instead of wall-clock timers ──
+    async function pumpLoops() {
+        const pendingTasks = new Map();
+        for (const entry of store.list()) {
+            if (entry.status !== "active")
+                continue;
+            if (!entry.autoTask)
+                continue;
+            if (entry.trigger.type !== "cron" && entry.trigger.type !== "hybrid")
+                continue;
+            const nextFire = scheduler.nextFire(entry.id);
+            if (!nextFire || Date.now() < nextFire)
+                continue;
+            const pending = await hasPendingTasks();
+            if (pending <= 0)
+                pendingTasks.set(entry.id, true);
+        }
+        scheduler.pump(Date.now(), (entry) => !pendingTasks.has(entry.id));
+    }
     // ── Loop fire handler — queues an in-memory notification, then injects a custom message when delivery is safe ──
     pi.events.on("loop:fire", async (event) => {
         const data = event;
@@ -425,8 +475,9 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
             "## readOnly mode",
             "Set readOnly: true for loops that only observe and report (checks, status polls). This prevents unintended changes.",
             "## Task-driven workflows",
-            "After creating tasks with TaskCreate, use an event loop with autoTask: true so the system checks for pending tasks before firing: LoopCreate trigger='tasks:created' triggerType='event' autoTask: true maxFires: 30 prompt='Run TaskList, pick the next available pending task, work on it.'",
-            "When no tasks are pending, the loop skips the wake entirely — no tokens burned on empty polls.",
+            "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.",
+            "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.",
         ],
         parameters: Type.Object({
@@ -439,7 +490,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
             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." })),
         }),
-        execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
             const { trigger: triggerInput, prompt, recurring, autoTask, triggerType, debounceMs, readOnly, maxFires } = params;
             let trigger;
             const inferred = triggerType ?? inferTriggerType(triggerInput);
@@ -467,7 +518,6 @@ 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,
-                selfPaced: triggerInput === "self-paced" || prompt.toLowerCase().includes("self-paced"),
                 readOnly,
                 maxFires,
             });
@@ -487,6 +537,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
                 }
                 catch { /* filter parse failure, ignore */ }
             }
+            const bootstrapped = await maybeBootstrapTaskLoop(entry);
             widget.update();
             const triggerDesc = trigger.type === "cron"
                 ? `schedule: ${trigger.schedule}`
@@ -497,6 +548,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` : "") +
+                (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)`));
         },
@@ -956,6 +1008,12 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
                 }
                 if (trimmed) {
                     const entry = nativeTaskStore.create(trimmed.slice(0, 80), trimmed);
+                    pi.events.emit("tasks:created", {
+                        taskId: entry.id,
+                        subject: entry.subject,
+                        description: entry.description,
+                        status: entry.status,
+                    });
                     widget.update();
                     ctx.ui.notify(`Task #${entry.id} created`, "info");
                     return;
@@ -982,6 +1040,12 @@ Fields:
             }),
             execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
                 const entry = taskStore.create(params.subject, params.description);
+                pi.events.emit("tasks:created", {
+                    taskId: entry.id,
+                    subject: entry.subject,
+                    description: entry.description,
+                    status: entry.status,
+                });
                 widget.update();
                 return Promise.resolve(textResult(`Task #${entry.id} created: ${entry.subject}`));
             },

package/dist/scheduler.d.ts

@@ -3,7 +3,6 @@ import type { LoopEntry } from "./types.js";
 export declare class CronScheduler {
     private store;
     private onFire;
-    private timers;
     private fireTimes;
     constructor(store: LoopStore, onFire: (entry: LoopEntry) => void);
     start(): void;
@@ -12,4 +11,5 @@ export declare class CronScheduler {
     remove(id: string): void;
     nextFire(id: string): number | undefined;
     private armTimer;
+    pump(now: number, filter?: (entry: LoopEntry) => boolean): void;
 }

package/dist/scheduler.js

@@ -9,7 +9,6 @@ function computeNextFire(entry) {
 export class CronScheduler {
     store;
     onFire;
-    timers = new Map();
     fireTimes = new Map();
     constructor(store, onFire) {
         this.store = store;
@@ -25,11 +24,7 @@ export class CronScheduler {
         }
     }
     stop() {
-        for (const [id, timer] of this.timers) {
-            clearTimeout(timer);
-            this.timers.delete(id);
-            this.fireTimes.delete(id);
-        }
+        this.fireTimes.clear();
     }
     add(entry) {
         if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid") {
@@ -37,10 +32,6 @@ export class CronScheduler {
         }
     }
     remove(id) {
-        const timer = this.timers.get(id);
-        if (timer)
-            clearTimeout(timer);
-        this.timers.delete(id);
         this.fireTimes.delete(id);
     }
     nextFire(id) {
@@ -53,46 +44,45 @@ export class CronScheduler {
         const minuteStep = minuteField.startsWith("*/") ? parseInt(minuteField.slice(2), 10) || 30 : 30;
         const jitter = computeJitter(entry.id, entry.recurring, minuteStep);
         const fireTime = nextFire.getTime() + jitter;
-        const now = Date.now();
         if (fireTime > entry.expiresAt) {
             this.store.delete(entry.id);
             return;
         }
-        const delay = Math.max(0, fireTime - now);
         this.fireTimes.set(entry.id, fireTime);
-        const existing = this.timers.get(entry.id);
-        if (existing)
-            clearTimeout(existing);
-        const timer = setTimeout(() => {
-            const current = this.store.get(entry.id);
-            if (!current || current.status !== "active") {
-                this.timers.delete(entry.id);
-                this.fireTimes.delete(entry.id);
-                return;
+    }
+    pump(now, filter) {
+        for (const [id, fireTime] of this.fireTimes) {
+            if (now < fireTime)
+                continue;
+            const entry = this.store.get(id);
+            if (!entry || entry.status !== "active") {
+                this.fireTimes.delete(id);
+                continue;
             }
-            const now2 = Date.now();
-            if (now2 >= current.expiresAt) {
-                this.store.delete(entry.id);
-                this.timers.delete(entry.id);
-                this.fireTimes.delete(entry.id);
-                return;
+            if (filter && !filter(entry))
+                continue;
+            if (now >= entry.expiresAt) {
+                this.store.delete(id);
+                this.fireTimes.delete(id);
+                continue;
             }
-            this.onFire(current);
-            if (current.recurring) {
-                const fresh = this.store.get(entry.id);
-                if (fresh?.maxFires && (fresh.fireCount ?? 0) >= fresh.maxFires) {
-                    this.store.delete(entry.id);
-                    this.timers.delete(entry.id);
-                    this.fireTimes.delete(entry.id);
-                    return;
-                }
-                this.armTimer(current);
+            this.onFire(entry);
+            const fresh = this.store.get(id);
+            if (!fresh) {
+                this.fireTimes.delete(id);
+                continue;
+            }
+            if (fresh.recurring && fresh.maxFires && (fresh.fireCount ?? 0) >= fresh.maxFires) {
+                this.store.delete(id);
+                this.fireTimes.delete(id);
+                continue;
+            }
+            if (fresh.recurring) {
+                this.armTimer(fresh);
             }
             else {
-                this.timers.delete(entry.id);
-                this.fireTimes.delete(entry.id);
+                this.fireTimes.delete(id);
             }
-        }, delay);
-        this.timers.set(entry.id, timer);
+        }
     }
 }

package/dist/store.d.ts

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

package/dist/store.js

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

package/dist/types.d.ts

@@ -28,7 +28,6 @@ export interface LoopEntry {
     updatedAt: number;
     expiresAt: number;
     autoTask?: boolean;
-    selfPaced?: boolean;
     readOnly?: boolean;
     maxFires?: number;
     fireCount?: number;

package/package.json

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

package/src/index.ts

@@ -229,6 +229,35 @@ export default function (pi: ExtensionAPI) {
     };
   }
 
+  function triggerHasEventSource(trigger: Trigger | string, source: string): boolean {
+    if (typeof trigger === "string") return false;
+    return trigger.type === "event"
+      ? trigger.source === source
+      : trigger.type === "hybrid"
+        ? trigger.event.source === source
+        : false;
+  }
+
+  async function maybeBootstrapTaskLoop(entry: LoopEntry): Promise<boolean> {
+    if (!entry.recurring) return false;
+    if (!triggerHasEventSource(entry.trigger, "tasks:created")) return false;
+
+    const pending = await hasPendingTasks();
+    if (pending <= 0) return false;
+
+    debug(`loop #${entry.id} — bootstrapping existing pending tasks (${pending})`);
+    await queueOrDeliverNotification({
+      loopId: entry.id,
+      prompt: entry.prompt,
+      trigger: entry.trigger,
+      timestamp: Date.now(),
+      readOnly: entry.readOnly,
+      recurring: false,
+      autoTask: true,
+    });
+    return true;
+  }
+
   async function deliverNotification(notification: PendingNotification): Promise<boolean> {
     if (notification.autoTask) {
       const pending = await hasPendingTasks();
@@ -352,6 +381,7 @@ export default function (pi: ExtensionAPI) {
     widget.setUICtx(ctx.ui);
     upgradeStoreIfNeeded(ctx);
     widget.update();
+    await pumpLoops();
   });
 
   pi.on("before_agent_start", async (_event, ctx) => {
@@ -373,6 +403,7 @@ export default function (pi: ExtensionAPI) {
     _latestCtx = ctx;
     widget.setUICtx(ctx.ui);
     await flushPendingNotifications();
+    await pumpLoops();
   });
 
   pi.on("session_shutdown", async () => {
@@ -400,6 +431,22 @@ export default function (pi: ExtensionAPI) {
     widget.update();
   });
 
+  // ── Dynamic loop pump — fires cron/hybrid loops on idle instead of wall-clock timers ──
+
+  async function pumpLoops(): Promise<void> {
+    const pendingTasks = new Map<string, boolean>();
+    for (const entry of store.list()) {
+      if (entry.status !== "active") continue;
+      if (!entry.autoTask) continue;
+      if (entry.trigger.type !== "cron" && entry.trigger.type !== "hybrid") continue;
+      const nextFire = scheduler.nextFire(entry.id);
+      if (!nextFire || Date.now() < nextFire) continue;
+      const pending = await hasPendingTasks();
+      if (pending <= 0) pendingTasks.set(entry.id, true);
+    }
+    scheduler.pump(Date.now(), (entry) => !pendingTasks.has(entry.id));
+  }
+
   // ── Loop fire handler — queues an in-memory notification, then injects a custom message when delivery is safe ──
 
   pi.events.on("loop:fire", async (event: unknown) => {
@@ -470,8 +517,9 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
       "## readOnly mode",
       "Set readOnly: true for loops that only observe and report (checks, status polls). This prevents unintended changes.",
       "## Task-driven workflows",
-      "After creating tasks with TaskCreate, use an event loop with autoTask: true so the system checks for pending tasks before firing: LoopCreate trigger='tasks:created' triggerType='event' autoTask: true maxFires: 30 prompt='Run TaskList, pick the next available pending task, work on it.'",
-      "When no tasks are pending, the loop skips the wake entirely — no tokens burned on empty polls.",
+      "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.",
+      "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.",
     ],
     parameters: Type.Object({
@@ -485,7 +533,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
       maxFires: Type.Optional(Type.Number({ description: "Auto-stop after N fires. Prevents infinite token burn on polling loops." })),
     }),
 
-    execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
       const { trigger: triggerInput, prompt, recurring, autoTask, triggerType, debounceMs, readOnly, maxFires } = params;
 
       let trigger: Trigger;
@@ -514,7 +562,6 @@ 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,
-        selfPaced: triggerInput === "self-paced" || prompt.toLowerCase().includes("self-paced"),
         readOnly,
         maxFires,
       });
@@ -536,6 +583,8 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
         } catch { /* filter parse failure, ignore */ }
       }
 
+      const bootstrapped = await maybeBootstrapTaskLoop(entry);
+
       widget.update();
 
       const triggerDesc = trigger.type === "cron"
@@ -549,6 +598,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` : "") +
+        (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)`
       ));
@@ -1040,6 +1090,12 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
         }
         if (trimmed) {
           const entry = nativeTaskStore.create(trimmed.slice(0, 80), trimmed);
+          pi.events.emit("tasks:created", {
+            taskId: entry.id,
+            subject: entry.subject,
+            description: entry.description,
+            status: entry.status,
+          });
           widget.update();
           ctx.ui.notify(`Task #${entry.id} created`, "info");
           return;
@@ -1067,6 +1123,12 @@ Fields:
       }),
       execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
         const entry = taskStore.create(params.subject, params.description);
+        pi.events.emit("tasks:created", {
+          taskId: entry.id,
+          subject: entry.subject,
+          description: entry.description,
+          status: entry.status,
+        });
         widget.update();
         return Promise.resolve(textResult(`Task #${entry.id} created: ${entry.subject}`));
       },

package/src/scheduler.ts

@@ -12,7 +12,6 @@ function computeNextFire(entry: LoopEntry): Date {
 }
 
 export class CronScheduler {
-  private timers = new Map<string, NodeJS.Timeout>();
   private fireTimes = new Map<string, number>();
 
   constructor(
@@ -30,11 +29,7 @@ export class CronScheduler {
   }
 
   stop(): void {
-    for (const [id, timer] of this.timers) {
-      clearTimeout(timer);
-      this.timers.delete(id);
-      this.fireTimes.delete(id);
-    }
+    this.fireTimes.clear();
   }
 
   add(entry: LoopEntry): void {
@@ -44,9 +39,6 @@ export class CronScheduler {
   }
 
   remove(id: string): void {
-    const timer = this.timers.get(id);
-    if (timer) clearTimeout(timer);
-    this.timers.delete(id);
     this.fireTimes.delete(id);
   }
 
@@ -62,52 +54,52 @@ export class CronScheduler {
     const minuteStep = minuteField.startsWith("*/") ? parseInt(minuteField.slice(2), 10) || 30 : 30;
     const jitter = computeJitter(entry.id, entry.recurring, minuteStep);
     const fireTime = nextFire.getTime() + jitter;
-    const now = Date.now();
 
     if (fireTime > entry.expiresAt) {
       this.store.delete(entry.id);
       return;
     }
 
-    const delay = Math.max(0, fireTime - now);
     this.fireTimes.set(entry.id, fireTime);
+  }
 
-    const existing = this.timers.get(entry.id);
-    if (existing) clearTimeout(existing);
+  pump(now: number, filter?: (entry: LoopEntry) => boolean): void {
+    for (const [id, fireTime] of this.fireTimes) {
+      if (now < fireTime) continue;
 
-    const timer = setTimeout(() => {
-      const current = this.store.get(entry.id);
-      if (!current || current.status !== "active") {
-        this.timers.delete(entry.id);
-        this.fireTimes.delete(entry.id);
-        return;
+      const entry = this.store.get(id);
+      if (!entry || entry.status !== "active") {
+        this.fireTimes.delete(id);
+        continue;
       }
 
-      const now2 = Date.now();
-      if (now2 >= current.expiresAt) {
-        this.store.delete(entry.id);
-        this.timers.delete(entry.id);
-        this.fireTimes.delete(entry.id);
-        return;
+      if (filter && !filter(entry)) continue;
+
+      if (now >= entry.expiresAt) {
+        this.store.delete(id);
+        this.fireTimes.delete(id);
+        continue;
       }
 
-      this.onFire(current);
-
-      if (current.recurring) {
-        const fresh = this.store.get(entry.id);
-        if (fresh?.maxFires && (fresh.fireCount ?? 0) >= fresh.maxFires) {
-          this.store.delete(entry.id);
-          this.timers.delete(entry.id);
-          this.fireTimes.delete(entry.id);
-          return;
-        }
-        this.armTimer(current);
-      } else {
-        this.timers.delete(entry.id);
-        this.fireTimes.delete(entry.id);
+      this.onFire(entry);
+
+      const fresh = this.store.get(id);
+      if (!fresh) {
+        this.fireTimes.delete(id);
+        continue;
       }
-    }, delay);
 
-    this.timers.set(entry.id, timer);
+      if (fresh.recurring && fresh.maxFires && (fresh.fireCount ?? 0) >= fresh.maxFires) {
+        this.store.delete(id);
+        this.fireTimes.delete(id);
+        continue;
+      }
+
+      if (fresh.recurring) {
+        this.armTimer(fresh);
+      } else {
+        this.fireTimes.delete(id);
+      }
+    }
   }
 }

package/src/store.ts

@@ -95,7 +95,7 @@ export class LoopStore {
     }
   }
 
-  create(trigger: Trigger, prompt: string, opts: { recurring: boolean; autoTask?: boolean; selfPaced?: boolean; readOnly?: boolean; maxFires?: number }): LoopEntry {
+  create(trigger: Trigger, prompt: string, opts: { recurring: boolean; autoTask?: 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,7 +108,6 @@ export class LoopStore {
         status: "active",
         recurring: opts.recurring,
         autoTask: opts.autoTask,
-        selfPaced: opts.selfPaced,
         readOnly: opts.readOnly,
         maxFires: opts.maxFires,
         fireCount: 0,

package/src/types.ts

@@ -30,7 +30,6 @@ export interface LoopEntry {
   updatedAt: number;
   expiresAt: number;
   autoTask?: boolean;
-  selfPaced?: boolean;
   readOnly?: boolean;
   maxFires?: number;
   fireCount?: number;