@trevonistrevon/pi-loop 0.4.3 → 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

@@ -350,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;
@@ -368,6 +369,7 @@ export default function (pi) {
         _latestCtx = ctx;
         widget.setUICtx(ctx.ui);
         await flushPendingNotifications();
+        await pumpLoops();
     });
     pi.on("session_shutdown", async () => {
         agentRunning = false;
@@ -389,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;
@@ -497,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,
             });

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.3",
+  "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

@@ -381,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) => {
@@ -402,6 +403,7 @@ export default function (pi: ExtensionAPI) {
     _latestCtx = ctx;
     widget.setUICtx(ctx.ui);
     await flushPendingNotifications();
+    await pumpLoops();
   });
 
   pi.on("session_shutdown", async () => {
@@ -429,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) => {
@@ -544,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,
       });

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;