@trevonistrevon/pi-loop 0.5.3 → 0.5.5

package/dist/store.js

@@ -1,135 +1,23 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, isAbsolute, join } from "node:path";
+import { join } from "node:path";
 import { reduceLoopState } from "./loop-reducer.js";
+import { ReducerBackedStore } from "./reducer-backed-store.js";
 const LOOPS_DIR = join(homedir(), ".pi", "loops");
-const LOCK_RETRY_MS = 50;
-const LOCK_MAX_RETRIES = 100;
 const MAX_LOOPS = 25;
-function acquireLock(lockPath) {
-    for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
-        try {
-            writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
-            return;
-        }
-        catch (e) {
-            if (e.code === "EEXIST") {
-                try {
-                    const pid = parseInt(readFileSync(lockPath, "utf-8"), 10);
-                    if (!pid || !isProcessRunning(pid)) {
-                        try {
-                            unlinkSync(lockPath);
-                        }
-                        catch { /* ignore */ }
-                        continue;
-                    }
-                }
-                catch { /* ignore read errors */ }
-                const start = Date.now();
-                while (Date.now() - start < LOCK_RETRY_MS) { /* busy wait */ }
-                continue;
-            }
-            throw e;
-        }
-    }
-    throw new Error(`Failed to acquire lock: ${lockPath}`);
-}
-function releaseLock(lockPath) {
-    try {
-        unlinkSync(lockPath);
-    }
-    catch { /* ignore */ }
-}
-function isProcessRunning(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export class LoopStore {
-    filePath;
-    lockPath;
-    lastLoadedSignature;
-    nextId = 1;
-    loops = new Map();
+export class LoopStore extends ReducerBackedStore {
     constructor(listIdOrPath) {
-        if (!listIdOrPath)
-            return;
-        const isAbsPath = isAbsolute(listIdOrPath);
-        const filePath = isAbsPath ? listIdOrPath : join(LOOPS_DIR, `${listIdOrPath}.json`);
-        mkdirSync(dirname(filePath), { recursive: true });
-        this.filePath = filePath;
-        this.lockPath = filePath + ".lock";
-        this.load();
-    }
-    getFileSignature() {
-        if (!this.filePath || !existsSync(this.filePath))
-            return undefined;
-        const stat = statSync(this.filePath);
-        return `${stat.mtimeMs}:${stat.size}`;
-    }
-    load(force = false) {
-        if (!this.filePath)
-            return;
-        const signature = this.getFileSignature();
-        if (!signature)
-            return;
-        if (!force && signature === this.lastLoadedSignature)
-            return;
-        try {
-            const data = JSON.parse(readFileSync(this.filePath, "utf-8"));
-            this.nextId = data.nextId;
-            this.loops.clear();
-            for (const loop of data.loops) {
-                this.loops.set(loop.id, loop);
-            }
-            this.lastLoadedSignature = signature;
-        }
-        catch { /* corrupt file — start fresh */ }
-    }
-    save() {
-        if (!this.filePath)
-            return;
-        const data = {
-            nextId: this.nextId,
-            loops: Array.from(this.loops.values()),
-        };
-        const tmpPath = this.filePath + ".tmp";
-        writeFileSync(tmpPath, JSON.stringify(data, null, 2));
-        renameSync(tmpPath, this.filePath);
-        this.lastLoadedSignature = this.getFileSignature();
-    }
-    withLock(fn) {
-        if (!this.lockPath)
-            return fn();
-        acquireLock(this.lockPath);
-        try {
-            this.load(true);
-            const result = fn();
-            this.save();
-            return result;
-        }
-        finally {
-            releaseLock(this.lockPath);
-        }
-    }
-    toReducerState() {
-        return {
-            nextId: this.nextId,
-            loopsById: Object.fromEntries(this.loops.entries()),
-        };
-    }
-    applyReducerEvent(event) {
-        const result = reduceLoopState(this.toReducerState(), event);
-        this.nextId = result.state.nextId;
-        this.loops = new Map(Object.entries(result.state.loopsById));
+        super({
+            baseDir: LOOPS_DIR,
+            reduce: (state, event) => reduceLoopState(state, event),
+            toReducerState: (nextId, entries) => ({ nextId, loopsById: Object.fromEntries(entries.entries()) }),
+            fromReducerState: (state) => ({ nextId: state.nextId, entries: new Map(Object.entries(state.loopsById)) }),
+            serialize: (nextId, entries) => ({ nextId, loops: Array.from(entries.values()) }),
+            deserialize: (data) => ({ nextId: data.nextId, entries: new Map(data.loops.map((l) => [l.id, l])) }),
+        }, listIdOrPath);
     }
     create(trigger, prompt, opts) {
         return this.withLock(() => {
-            if (this.loops.size >= MAX_LOOPS) {
+            if (this.entries.size >= MAX_LOOPS) {
                 throw new Error(`Maximum of ${MAX_LOOPS} loops reached. Delete some before creating new ones.`);
             }
             const now = Date.now();
@@ -148,22 +36,12 @@ export class LoopStore {
                     maxFires: opts.maxFires,
                 },
             });
-            return this.loops.get(String(this.nextId - 1));
+            return this.entries.get(String(this.nextId - 1));
         });
     }
-    get(id) {
-        if (this.filePath)
-            this.load();
-        return this.loops.get(id);
-    }
-    list() {
-        if (this.filePath)
-            this.load();
-        return Array.from(this.loops.values()).sort((a, b) => Number(a.id) - Number(b.id));
-    }
     pause(id) {
         return this.withLock(() => {
-            const entry = this.loops.get(id);
+            const entry = this.entries.get(id);
             if (!entry)
                 return undefined;
             this.applyReducerEvent({
@@ -174,12 +52,12 @@ export class LoopStore {
                 entityId: id,
                 payload: { id },
             });
-            return this.loops.get(id);
+            return this.entries.get(id);
         });
     }
     resume(id) {
         return this.withLock(() => {
-            const entry = this.loops.get(id);
+            const entry = this.entries.get(id);
             if (!entry)
                 return undefined;
             this.applyReducerEvent({
@@ -190,12 +68,12 @@ export class LoopStore {
                 entityId: id,
                 payload: { id },
             });
-            return this.loops.get(id);
+            return this.entries.get(id);
         });
     }
     fire(id) {
         return this.withLock(() => {
-            const entry = this.loops.get(id);
+            const entry = this.entries.get(id);
             if (!entry)
                 return undefined;
             this.applyReducerEvent({
@@ -206,12 +84,12 @@ export class LoopStore {
                 entityId: id,
                 payload: { id },
             });
-            return this.loops.get(id);
+            return this.entries.get(id);
         });
     }
     updateMetadata(id, fields) {
         return this.withLock(() => {
-            const current = this.loops.get(id);
+            const current = this.entries.get(id);
             if (!current)
                 return { entry: undefined, changedFields: [] };
             const changedFields = [];
@@ -227,12 +105,12 @@ export class LoopStore {
             if (changedFields.length > 0) {
                 current.updatedAt = now;
             }
-            return { entry: this.loops.get(id), changedFields };
+            return { entry: this.entries.get(id), changedFields };
         });
     }
     delete(id) {
         return this.withLock(() => {
-            if (!this.loops.has(id))
+            if (!this.entries.has(id))
                 return false;
             this.applyReducerEvent({
                 type: "LOOP_DELETED",
@@ -249,7 +127,7 @@ export class LoopStore {
         return this.withLock(() => {
             const now = Date.now();
             let count = 0;
-            for (const [id, entry] of [...this.loops.entries()]) {
+            for (const [id, entry] of [...this.entries.entries()]) {
                 if (now < entry.expiresAt)
                     continue;
                 this.applyReducerEvent({
@@ -268,7 +146,7 @@ export class LoopStore {
     expireEventLoops(sessionStartedAt) {
         return this.withLock(() => {
             let count = 0;
-            for (const [id, entry] of [...this.loops.entries()]) {
+            for (const [id, entry] of [...this.entries.entries()]) {
                 if (entry.status !== "active")
                     continue;
                 if (entry.trigger.type !== "event" && entry.trigger.type !== "hybrid")
@@ -290,7 +168,7 @@ export class LoopStore {
     }
     clearAll() {
         return this.withLock(() => {
-            const ids = [...this.loops.keys()];
+            const ids = [...this.entries.keys()];
             for (const id of ids) {
                 this.applyReducerEvent({
                     type: "LOOP_DELETED",
@@ -304,13 +182,4 @@ export class LoopStore {
             return ids.length;
         });
     }
-    deleteFileIfEmpty() {
-        if (!this.filePath || this.loops.size > 0)
-            return false;
-        try {
-            unlinkSync(this.filePath);
-        }
-        catch { /* ignore */ }
-        return true;
-    }
 }

package/dist/task-reducer.js

@@ -60,6 +60,9 @@ export function reduceTaskState(state, event) {
     if (event.type === "TASK_REOPENED") {
         task.status = "pending";
         task.updatedAt = event.at;
+        // `completedAt` is intentionally retained: it records the most recent
+        // completion, not "is currently complete" (use `status` for that). A
+        // reopened task keeps the timestamp of when it was last completed.
     }
     if (event.type === "TASK_UPDATED") {
         if (event.payload.subject !== undefined)

package/dist/task-store.d.ts

@@ -1,20 +1,9 @@
-import type { TaskEntry } from "./task-types.js";
-export declare class TaskStore {
-    private filePath;
-    private lockPath;
-    private lastLoadedSignature;
-    private nextId;
-    private tasks;
+import { ReducerBackedStore } from "./reducer-backed-store.js";
+import { type TaskReducerEvent, type TaskReducerState } from "./task-reducer.js";
+import type { TaskEntry, TaskStoreData } from "./task-types.js";
+export declare class TaskStore extends ReducerBackedStore<TaskEntry, TaskReducerState, TaskReducerEvent, TaskStoreData> {
     constructor(listIdOrPath?: string);
-    private getFileSignature;
-    private load;
-    private save;
-    private withLock;
-    private toReducerState;
-    private applyReducerEvent;
     create(subject: string, description: string, metadata?: Record<string, unknown>): TaskEntry;
-    get(id: string): TaskEntry | undefined;
-    list(): TaskEntry[];
     start(id: string): TaskEntry | undefined;
     complete(id: string): TaskEntry | undefined;
     reopen(id: string): TaskEntry | undefined;

package/dist/task-store.js

@@ -1,135 +1,23 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, isAbsolute, join } from "node:path";
+import { join } from "node:path";
+import { ReducerBackedStore } from "./reducer-backed-store.js";
 import { reduceTaskState } from "./task-reducer.js";
 const TASKS_DIR = join(homedir(), ".pi", "tasks");
-const LOCK_RETRY_MS = 50;
-const LOCK_MAX_RETRIES = 100;
 const MAX_TASKS = 200;
-function acquireLock(lockPath) {
-    for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
-        try {
-            writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
-            return;
-        }
-        catch (e) {
-            if (e.code === "EEXIST") {
-                try {
-                    const pid = parseInt(readFileSync(lockPath, "utf-8"), 10);
-                    if (!pid || !isProcessRunning(pid)) {
-                        try {
-                            unlinkSync(lockPath);
-                        }
-                        catch { /* ignore */ }
-                        continue;
-                    }
-                }
-                catch { /* ignore read errors */ }
-                const start = Date.now();
-                while (Date.now() - start < LOCK_RETRY_MS) { /* busy wait */ }
-                continue;
-            }
-            throw e;
-        }
-    }
-    throw new Error(`Failed to acquire lock: ${lockPath}`);
-}
-function releaseLock(lockPath) {
-    try {
-        unlinkSync(lockPath);
-    }
-    catch { /* ignore */ }
-}
-function isProcessRunning(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export class TaskStore {
-    filePath;
-    lockPath;
-    lastLoadedSignature;
-    nextId = 1;
-    tasks = new Map();
+export class TaskStore extends ReducerBackedStore {
     constructor(listIdOrPath) {
-        if (!listIdOrPath)
-            return;
-        const isAbsPath = isAbsolute(listIdOrPath);
-        const filePath = isAbsPath ? listIdOrPath : join(TASKS_DIR, `${listIdOrPath}.json`);
-        mkdirSync(dirname(filePath), { recursive: true });
-        this.filePath = filePath;
-        this.lockPath = filePath + ".lock";
-        this.load();
-    }
-    getFileSignature() {
-        if (!this.filePath || !existsSync(this.filePath))
-            return undefined;
-        const stat = statSync(this.filePath);
-        return `${stat.mtimeMs}:${stat.size}`;
-    }
-    load(force = false) {
-        if (!this.filePath)
-            return;
-        const signature = this.getFileSignature();
-        if (!signature)
-            return;
-        if (!force && signature === this.lastLoadedSignature)
-            return;
-        try {
-            const data = JSON.parse(readFileSync(this.filePath, "utf-8"));
-            this.nextId = data.nextId;
-            this.tasks.clear();
-            for (const task of data.tasks) {
-                this.tasks.set(task.id, task);
-            }
-            this.lastLoadedSignature = signature;
-        }
-        catch { /* corrupt file — start fresh */ }
-    }
-    save() {
-        if (!this.filePath)
-            return;
-        const data = {
-            nextId: this.nextId,
-            tasks: Array.from(this.tasks.values()),
-        };
-        const tmpPath = this.filePath + ".tmp";
-        writeFileSync(tmpPath, JSON.stringify(data, null, 2));
-        renameSync(tmpPath, this.filePath);
-        this.lastLoadedSignature = this.getFileSignature();
-    }
-    withLock(fn) {
-        if (!this.lockPath)
-            return fn();
-        acquireLock(this.lockPath);
-        try {
-            this.load(true);
-            const result = fn();
-            this.save();
-            return result;
-        }
-        finally {
-            releaseLock(this.lockPath);
-        }
-    }
-    toReducerState() {
-        return {
-            nextId: this.nextId,
-            tasksById: Object.fromEntries(this.tasks.entries()),
-        };
-    }
-    applyReducerEvent(event) {
-        const result = reduceTaskState(this.toReducerState(), event);
-        this.nextId = result.state.nextId;
-        this.tasks = new Map(Object.entries(result.state.tasksById));
+        super({
+            baseDir: TASKS_DIR,
+            reduce: (state, event) => reduceTaskState(state, event),
+            toReducerState: (nextId, entries) => ({ nextId, tasksById: Object.fromEntries(entries.entries()) }),
+            fromReducerState: (state) => ({ nextId: state.nextId, entries: new Map(Object.entries(state.tasksById)) }),
+            serialize: (nextId, entries) => ({ nextId, tasks: Array.from(entries.values()) }),
+            deserialize: (data) => ({ nextId: data.nextId, entries: new Map(data.tasks.map((t) => [t.id, t])) }),
+        }, listIdOrPath);
     }
     create(subject, description, metadata) {
         return this.withLock(() => {
-            if (this.tasks.size >= MAX_TASKS) {
+            if (this.entries.size >= MAX_TASKS) {
                 throw new Error(`Maximum of ${MAX_TASKS} tasks reached. Delete some before creating new ones.`);
             }
             const now = Date.now();
@@ -140,22 +28,12 @@ export class TaskStore {
                 entityType: "task",
                 payload: { subject, description, metadata },
             });
-            return this.tasks.get(String(this.nextId - 1));
+            return this.entries.get(String(this.nextId - 1));
         });
     }
-    get(id) {
-        if (this.filePath)
-            this.load();
-        return this.tasks.get(id);
-    }
-    list() {
-        if (this.filePath)
-            this.load();
-        return Array.from(this.tasks.values()).sort((a, b) => Number(a.id) - Number(b.id));
-    }
     start(id) {
         return this.withLock(() => {
-            const entry = this.tasks.get(id);
+            const entry = this.entries.get(id);
             if (!entry)
                 return undefined;
             this.applyReducerEvent({
@@ -166,12 +44,12 @@ export class TaskStore {
                 entityId: id,
                 payload: { id },
             });
-            return this.tasks.get(id);
+            return this.entries.get(id);
         });
     }
     complete(id) {
         return this.withLock(() => {
-            const entry = this.tasks.get(id);
+            const entry = this.entries.get(id);
             if (!entry)
                 return undefined;
             this.applyReducerEvent({
@@ -182,12 +60,12 @@ export class TaskStore {
                 entityId: id,
                 payload: { id },
             });
-            return this.tasks.get(id);
+            return this.entries.get(id);
         });
     }
     reopen(id) {
         return this.withLock(() => {
-            const entry = this.tasks.get(id);
+            const entry = this.entries.get(id);
             if (!entry)
                 return undefined;
             this.applyReducerEvent({
@@ -198,12 +76,12 @@ export class TaskStore {
                 entityId: id,
                 payload: { id },
             });
-            return this.tasks.get(id);
+            return this.entries.get(id);
         });
     }
     updateDetails(id, fields) {
         return this.withLock(() => {
-            const entry = this.tasks.get(id);
+            const entry = this.entries.get(id);
             if (!entry)
                 return undefined;
             if (fields.subject === undefined && fields.description === undefined)
@@ -220,12 +98,12 @@ export class TaskStore {
                     description: fields.description,
                 },
             });
-            return this.tasks.get(id);
+            return this.entries.get(id);
         });
     }
     delete(id) {
         return this.withLock(() => {
-            if (!this.tasks.has(id))
+            if (!this.entries.has(id))
                 return false;
             this.applyReducerEvent({
                 type: "TASK_DELETED",
@@ -240,7 +118,7 @@ export class TaskStore {
     }
     pendingCount() {
         let count = 0;
-        for (const t of this.tasks.values()) {
+        for (const t of this.entries.values()) {
             if (t.status === "pending" || t.status === "in_progress")
                 count++;
         }
@@ -248,7 +126,7 @@ export class TaskStore {
     }
     pruneCompleted() {
         return this.withLock(() => {
-            const before = this.tasks.size;
+            const before = this.entries.size;
             this.applyReducerEvent({
                 type: "TASKS_PRUNED",
                 at: Date.now(),
@@ -256,7 +134,7 @@ export class TaskStore {
                 entityType: "task",
                 payload: { reason: "manual" },
             });
-            return before - this.tasks.size;
+            return before - this.entries.size;
         });
     }
 }

package/dist/tools/loop-tools.js

@@ -96,7 +96,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.",
+            "Set taskBacklog: true for backlog worker loops that process the existing pending queue. Backlog worker 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.",
         ],
@@ -170,10 +170,10 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
             return Promise.resolve(textResult(`Loop #${entry.id} created: ${entry.prompt.slice(0, 60)}\n` +
                 `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" : "") +
-                (isTaskSystemReady() ? "" : "(task system not ready yet — autoTask may not fire until native fallback or pi-tasks becomes available)\n") +
+                (entry.autoTask ? "Auto-create task: enabled\n" : "") +
+                (entry.taskBacklog ? "Backlog worker: enabled\n" : "") +
+                (bootstrapped ? "Backlog: initial wake queued for existing pending tasks\n" : "") +
+                (isTaskSystemReady() ? "" : "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)`));
         },
     });
@@ -205,6 +205,8 @@ Use this before creating new loops to avoid duplicates, or to find IDs for LoopD
                 }
                 if (entry.autoTask)
                     line += " [auto-task]";
+                if (entry.taskBacklog)
+                    line += " [backlog-worker]";
                 lines.push(line);
             }
             return Promise.resolve(textResult(lines.join("\n")));

package/dist/tools/monitor-tools.js

@@ -52,10 +52,19 @@ Pass onDone with a prompt and the monitor auto-creates a one-shot loop that fire
             updateWidget();
             let onDoneMsg = "";
             if (params.onDone) {
+                // onDone delivery is callback-only: the loop below is delivered solely
+                // via MonitorManager.onComplete (see handleMonitorDoneLoop →
+                // monitor-ondone-runtime), so it fires exactly once by construction.
+                // The event-typed trigger is metadata, NOT a live subscription — this
+                // loop is deliberately NOT passed to triggerSystem.add(). The "event"
+                // type lets expireEventLoops() prune it if orphaned across a session
+                // and lets the widget render it as a monitor-completion wake. Do not
+                // triggerSystem.add() this loop, or the monitor:done event would fire it
+                // a second time.
                 const doneTrigger = { type: "event", source: "monitor:done", filter: JSON.stringify({ monitorId: entry.id }) };
                 const doneLoop = getStore().create(doneTrigger, params.onDone, { recurring: false });
                 handleMonitorDoneLoop(doneLoop, entry.id);
-                onDoneMsg = `\nonDone loop #${doneLoop.id}: fires when monitor completes — no polling needed`;
+                onDoneMsg = `\nCompletion wake loop #${doneLoop.id}: fires when the monitor completes — no polling needed`;
             }
             return Promise.resolve(textResult(`Monitor #${entry.id} started: ${entry.command.slice(0, 60)}\n` +
                 `Output stream: monitor:output (monitorId: ${entry.id})\n` +
@@ -70,10 +79,10 @@ Pass onDone with a prompt and the monitor auto-creates a one-shot loop that fire
         execute() {
             const monitors = getMonitorManager().list();
             if (monitors.length === 0)
-                return Promise.resolve(textResult("No monitors running."));
+                return Promise.resolve(textResult("No monitors."));
             const lines = [];
             for (const m of monitors) {
-                const icon = m.status === "running" ? ">" : m.status === "completed" ? "ok" : "!!";
+                const icon = m.status === "running" ? ">" : m.status === "completed" ? "ok" : "x";
                 const age = Date.now() - m.startedAt;
                 const ageStr = formatRemaining(age);
                 let line = `${icon} #${m.id} [${m.status}] ${m.command.slice(0, 60)} — ${m.outputLines} lines (${ageStr})`;

package/dist/tools/native-task-tools.js

@@ -39,7 +39,7 @@ Fields:
             const backlog = await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
             updateWidget();
             const autoLoopMsg = backlog.created && backlog.entry
-                ? `\nWorker loop #${backlog.entry.id} auto-created`
+                ? `\nBacklog worker loop #${backlog.entry.id} created`
                 : "";
             return Promise.resolve(textResult(`Task #${entry.id} created: ${entry.subject}${autoLoopMsg}`));
         },
@@ -108,7 +108,7 @@ Parameters: id (required), status, subject, description`,
             const backlog = await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
             const statusMsg = status ? ` → ${status}` : "";
             const autoLoopMsg = backlog.created && backlog.entry
-                ? `\nWorker loop #${backlog.entry.id} auto-created`
+                ? `\nBacklog worker loop #${backlog.entry.id} created`
                 : "";
             return Promise.resolve(textResult(`Task #${id} updated${statusMsg}${autoLoopMsg}`));
         },

package/dist/trigger-system.js

@@ -1,3 +1,4 @@
+import { atMaxFires } from "./loop-reducer.js";
 export class TriggerSystem {
     pi;
     scheduler;
@@ -103,7 +104,7 @@ export class TriggerSystem {
             this.remove(entry.id);
             return;
         }
-        if (fresh.recurring && fresh.maxFires && (fresh.fireCount ?? 0) >= fresh.maxFires) {
+        if (fresh.recurring && atMaxFires(fresh)) {
             this.remove(fresh.id);
             this.store.delete(fresh.id);
             return;