@trevonistrevon/pi-loop 0.6.0 → 0.6.2

package/dist/loop-parse.js

@@ -50,9 +50,53 @@ function isFullCron(expr) {
     const parts = expr.trim().split(/\s+/);
     return parts.length === 5;
 }
+function parseCronNumber(input, min, max) {
+    if (!/^\d+$/.test(input))
+        return undefined;
+    const value = Number.parseInt(input, 10);
+    return value >= min && value <= max ? value : undefined;
+}
+function isValidCronField(field, min, max) {
+    return field.split(",").every((part) => {
+        const [base, step, extra] = part.split("/");
+        if (extra !== undefined || base === undefined)
+            return false;
+        if (step !== undefined && (parseCronNumber(step, 1, max - min + 1) === undefined))
+            return false;
+        if (base === "*")
+            return true;
+        const range = base.split("-");
+        if (range.length === 1)
+            return step === undefined && parseCronNumber(base, min, max) !== undefined;
+        if (range.length !== 2)
+            return false;
+        const start = parseCronNumber(range[0] ?? "", min, max);
+        const end = parseCronNumber(range[1] ?? "", min, max);
+        return start !== undefined && end !== undefined && start <= end;
+    });
+}
+export function isValidCronExpression(expr) {
+    const fields = expr.trim().split(/\s+/);
+    if (fields.length !== 5)
+        return false;
+    const ranges = [
+        [0, 59],
+        [0, 23],
+        [1, 31],
+        [1, 12],
+        [0, 6],
+    ];
+    return fields.every((field, index) => {
+        const range = ranges[index];
+        return range !== undefined && isValidCronField(field, range[0], range[1]);
+    });
+}
 export function parseInterval(input) {
     const trimmed = input.trim();
     if (isFullCron(trimmed)) {
+        if (!isValidCronExpression(trimmed)) {
+            throw new Error(`Invalid cron expression: ${trimmed}`);
+        }
         return { cron: trimmed, description: `cron: ${trimmed}` };
     }
     const match = trimmed.match(/^(\d+)\s*(s|m|h|d)$/i);
@@ -69,7 +113,7 @@ export function parseInterval(input) {
 }
 export function cronToNextFire(cronExpr, fromDate = new Date()) {
     const parts = cronExpr.trim().split(/\s+/);
-    if (parts.length !== 5)
+    if (!isValidCronExpression(cronExpr))
         throw new Error(`Invalid cron expression: ${cronExpr}`);
     const [minF, hourF, dayF, monthF, dowF] = parts;
     if (minF === undefined ||

package/dist/loop-reducer.d.ts

@@ -1,4 +1,4 @@
-import type { LoopEntry, Trigger } from "./types.js";
+import type { DynamicLoopState, LoopEntry, Trigger } from "./types.js";
 export declare const MAX_LOOP_EXPIRY_MS: number;
 /**
  * Whether a loop has reached its fire cap. Single source of truth for the
@@ -26,6 +26,7 @@ export type LoopReducerEvent = {
         taskBacklog?: boolean;
         readOnly?: boolean;
         maxFires?: number;
+        dynamic?: Partial<DynamicLoopState>;
     };
 } | {
     type: "LOOP_PAUSED" | "LOOP_RESUMED" | "LOOP_FIRED" | "LOOP_DELETED" | "LOOP_MAX_FIRES_REACHED" | "LOOP_BACKLOG_EMPTY";
@@ -46,6 +47,17 @@ export type LoopReducerEvent = {
         id: string;
         reason: "expires_at" | "resume_event_stale" | "already_completed_monitor";
     };
+} | {
+    type: "LOOP_DYNAMIC_UPDATED";
+    at: number;
+    source: ReducerSource;
+    entityType?: "loop";
+    entityId?: string;
+    payload: {
+        id: string;
+        prompt?: string;
+        dynamic: Partial<DynamicLoopState>;
+    };
 };
 export type LoopReducerEffect = {
     type: "PERSIST_LOOP";

package/dist/loop-reducer.js

@@ -32,6 +32,18 @@ export function reduceLoopState(state, event) {
             readOnly: event.payload.readOnly,
             maxFires: event.payload.maxFires,
             fireCount: 0,
+            dynamic: event.payload.trigger.type === "dynamic" || event.payload.dynamic
+                ? {
+                    goal: event.payload.dynamic?.goal ?? event.payload.prompt,
+                    state: event.payload.dynamic?.state,
+                    metrics: event.payload.dynamic?.metrics,
+                    doneCriteria: event.payload.dynamic?.doneCriteria,
+                    iteration: event.payload.dynamic?.iteration ?? 0,
+                    nextWakeAt: event.payload.dynamic?.nextWakeAt,
+                    awaitingUpdate: event.payload.dynamic?.awaitingUpdate ?? false,
+                    lastUpdatedAt: event.payload.dynamic?.lastUpdatedAt ?? event.at,
+                }
+                : undefined,
         };
         next.loopsById[id] = loop;
         return {
@@ -68,6 +80,20 @@ export function reduceLoopState(state, event) {
         loop.fireCount = (loop.fireCount ?? 0) + 1;
         loop.updatedAt = event.at;
     }
+    if (event.type === "LOOP_DYNAMIC_UPDATED") {
+        loop.prompt = event.payload.prompt ?? loop.prompt;
+        loop.dynamic = {
+            goal: event.payload.dynamic.goal ?? loop.dynamic?.goal ?? loop.prompt,
+            state: event.payload.dynamic.state ?? loop.dynamic?.state,
+            metrics: event.payload.dynamic.metrics ?? loop.dynamic?.metrics,
+            doneCriteria: event.payload.dynamic.doneCriteria ?? loop.dynamic?.doneCriteria,
+            iteration: event.payload.dynamic.iteration ?? loop.dynamic?.iteration ?? 0,
+            nextWakeAt: "nextWakeAt" in event.payload.dynamic ? event.payload.dynamic.nextWakeAt : loop.dynamic?.nextWakeAt,
+            awaitingUpdate: event.payload.dynamic.awaitingUpdate ?? loop.dynamic?.awaitingUpdate ?? false,
+            lastUpdatedAt: event.payload.dynamic.lastUpdatedAt ?? event.at,
+        };
+        loop.updatedAt = event.at;
+    }
     next.loopsById[id] = loop;
     return {
         state: next,

package/dist/monitor-manager.d.ts

@@ -22,7 +22,7 @@ export declare class MonitorManager {
     create(command: string, description?: string, timeout?: number): MonitorEntry;
     get(id: string): MonitorEntry | undefined;
     list(): MonitorEntry[];
-    stop(id: string): Promise<boolean>;
+    stop(id: string, reason?: "manual" | "timeout"): Promise<boolean>;
     onComplete(id: string, callback: () => void): boolean;
     getProcess(id: string): MonitorProcess | undefined;
 }

package/dist/monitor-manager.js

@@ -190,7 +190,7 @@ export class MonitorManager {
         if (timeout > 0) {
             setTimeout(() => {
                 if (bp.entry.status === "running") {
-                    this.stop(id);
+                    void this.stop(id, "timeout");
                 }
             }, timeout);
         }
@@ -206,7 +206,7 @@ export class MonitorManager {
             .map(bp => bp.entry)
             .sort((a, b) => Number(a.id) - Number(b.id));
     }
-    async stop(id) {
+    async stop(id, reason = "manual") {
         const bp = this.processes.get(id);
         if (!bp || bp.entry.status !== "running")
             return false;
@@ -218,7 +218,7 @@ export class MonitorManager {
             entityId: id,
             payload: {
                 id,
-                reason: "manual",
+                reason,
             },
         });
         this.schedulePrune(id);
@@ -236,6 +236,15 @@ export class MonitorManager {
                 resolve();
             });
         });
+        if (reason === "timeout") {
+            this.pi.events.emit("monitor:error", {
+                monitorId: id,
+                error: `Timed out after ${bp.entry.timeout}ms`,
+                outputLines: bp.entry.outputLines,
+            });
+            for (const callback of bp.completionCallbacks)
+                callback();
+        }
         bp.completionCallbacks = [];
         for (const resolve of bp.waiters)
             resolve();
@@ -246,7 +255,7 @@ export class MonitorManager {
         const bp = this.processes.get(id);
         if (!bp)
             return false;
-        if (bp.entry.status === "completed") {
+        if (bp.entry.status === "completed" || bp.entry.status === "error") {
             callback();
             return true;
         }

package/dist/notification-reducer.d.ts

@@ -1,3 +1,4 @@
+import type { DynamicLoopState } from "./types.js";
 type ReducerSource = "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
 export interface ReducerNotification {
     key: string;
@@ -8,6 +9,7 @@ export interface ReducerNotification {
     recurring?: boolean;
     autoTask?: boolean;
     readOnly?: boolean;
+    dynamic?: DynamicLoopState;
 }
 export interface NotificationReducerState {
     notificationsByKey: Record<string, ReducerNotification>;

package/dist/runtime/monitor-ondone-runtime.js

@@ -37,7 +37,7 @@ export function createMonitorOnDoneRuntime(options) {
             return;
         const monitor = monitorManager.get(monitorId);
         if (monitor && monitor.status !== "running") {
-            if (monitor.status === "completed") {
+            if (monitor.status === "completed" || monitor.status === "error") {
                 deliver();
                 return;
             }

package/dist/runtime/notification-runtime.d.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { Trigger } from "../types.js";
+import type { DynamicLoopState, Trigger } from "../types.js";
 export interface LoopFireEvent {
     loopId: string;
     prompt: string;
@@ -8,6 +8,7 @@ export interface LoopFireEvent {
     readOnly?: boolean;
     recurring?: boolean;
     autoTask?: boolean;
+    dynamic?: DynamicLoopState;
 }
 export interface PendingNotification extends LoopFireEvent {
     key: string;

package/dist/runtime/notification-runtime.js

@@ -1,4 +1,5 @@
 import { createCoordinator, } from "../coordinator.js";
+import { formatTrigger } from "../loop-format.js";
 import { reduceNotificationState, } from "../notification-reducer.js";
 export function createNotificationRuntime(options) {
     const { pi, hasPendingTasks, cleanDoneTasks, getHasPendingMessages, debug } = options;
@@ -43,18 +44,28 @@ export function createNotificationRuntime(options) {
         });
     }
     function buildLoopFireMessage(data) {
-        const triggerInfo = typeof data.trigger === "string"
-            ? data.trigger
-            : data.trigger?.type === "cron"
-                ? `schedule: ${data.trigger.schedule}`
-                : data.trigger?.type === "event"
-                    ? `event: ${data.trigger.source}`
-                    : "hybrid";
+        const triggerInfo = formatTrigger(data.trigger, "notification");
         const loopId = data.loopId || "?";
         const prompt = data.prompt || "loop fired";
         const constraint = data.readOnly
             ? "\n\nREAD-ONLY MODE — use only read tools (Read, TaskList, LoopList, MonitorList, etc.). No file writes, shell execution, or destructive changes."
             : "";
+        if (data.dynamic || (typeof data.trigger !== "string" && data.trigger?.type === "dynamic")) {
+            const dynamic = data.dynamic;
+            const lines = [
+                `[pi-loop] Loop #${loopId} fired (dynamic).${constraint}`,
+                `Goal: ${dynamic?.goal ?? prompt}`,
+                `Iteration: ${dynamic?.iteration ?? 0}`,
+            ];
+            if (dynamic?.state)
+                lines.push(`State: ${dynamic.state}`);
+            if (dynamic?.metrics)
+                lines.push(`Metrics: ${dynamic.metrics}`);
+            if (dynamic?.doneCriteria)
+                lines.push(`Done criteria: ${dynamic.doneCriteria}`);
+            lines.push("Continue toward the goal. When done call LoopUpdate with status=\"completed\". If more work remains, call LoopUpdate with status=\"continue\" plus state/metrics. Omit nextInterval for idle-driven rewake; include nextInterval for a timed wake. If blocked, use status=\"paused\".");
+            return lines.join("\n");
+        }
         return [
             `[pi-loop] Loop #${loopId} fired (${triggerInfo}).${constraint}`,
             prompt,
@@ -88,6 +99,7 @@ export function createNotificationRuntime(options) {
                 recurring: notification.recurring,
                 readOnly: notification.readOnly,
                 autoTask: notification.autoTask,
+                dynamic: notification.dynamic,
                 timestamp: notification.timestamp,
             },
         }, {

package/dist/runtime/task-backlog-runtime.d.ts

@@ -1,5 +1,5 @@
 import type { TaskStore } from "../task-store.js";
-import type { LoopEntry, Trigger } from "../types.js";
+import type { LoopDeletionTombstoneInput, LoopEntry, Trigger } from "../types.js";
 import { type LoopAutodeletedPayload, type TaskBacklogEmptyPayload } from "./loop-events.js";
 export declare const AUTO_TASK_WORKER_THRESHOLD = 5;
 export declare 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.";
@@ -11,6 +11,7 @@ export interface TaskBacklogRuntimeOptions {
         maxFires?: number;
     }) => LoopEntry;
     deleteLoop: (id: string) => void;
+    recordDeletionTombstone?: (id: string, tombstone: LoopDeletionTombstoneInput) => void;
     addTrigger: (entry: LoopEntry) => void;
     removeTrigger: (id: string) => void;
     updateWidget: () => void;

package/dist/runtime/task-backlog-runtime.js

@@ -4,7 +4,7 @@ import { buildLoopAutodeletedPayload, buildTaskBacklogEmptyPayload, } from "./lo
 export const AUTO_TASK_WORKER_THRESHOLD = 5;
 export 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.";
 export function createTaskBacklogRuntime(options) {
-    const { getLoops, createLoop, deleteLoop, addTrigger, removeTrigger, updateWidget, hasPendingTasks, bootstrapTaskLoop, triggerHasEventSource, emitLoopAutodeleted, emitTaskBacklogEmpty, debug, } = options;
+    const { getLoops, createLoop, deleteLoop, recordDeletionTombstone, addTrigger, removeTrigger, updateWidget, hasPendingTasks, bootstrapTaskLoop, triggerHasEventSource, emitLoopAutodeleted, emitTaskBacklogEmpty, debug, } = options;
     function isAutoTaskWorkerLoop(entry) {
         return entry.status === "active"
             && entry.prompt === AUTO_TASK_WORKER_PROMPT
@@ -18,6 +18,13 @@ export function createTaskBacklogRuntime(options) {
     function findAutoTaskWorkerLoop() {
         return getLoops().find(isAutoTaskWorkerLoop);
     }
+    function deleteTaskBacklogLoop(entry, pendingCount) {
+        debug?.(`task backlog loop #${entry.id} — no pending tasks remain, deleting`);
+        removeTrigger(entry.id);
+        recordDeletionTombstone?.(entry.id, { reason: "task_backlog_empty", pendingCount });
+        deleteLoop(entry.id);
+        emitLoopAutodeleted?.(buildLoopAutodeletedPayload(entry, pendingCount));
+    }
     async function cleanupTaskBacklogLoops() {
         const backlogLoops = getLoops().filter(isTaskBacklogLoop);
         if (backlogLoops.length === 0)
@@ -25,13 +32,10 @@ export function createTaskBacklogRuntime(options) {
         const pending = await hasPendingTasks();
         if (pending < 0 || pending > 0)
             return 0;
-        emitTaskBacklogEmpty?.(buildTaskBacklogEmptyPayload(backlogLoops.map((entry) => entry.id)));
-        for (const entry of backlogLoops) {
-            debug?.(`task backlog loop #${entry.id} — no pending tasks remain, deleting`);
-            removeTrigger(entry.id);
-            deleteLoop(entry.id);
-            emitLoopAutodeleted?.(buildLoopAutodeletedPayload(entry, pending));
-        }
+        const deletedLoopIds = backlogLoops.map((entry) => entry.id);
+        emitTaskBacklogEmpty?.(buildTaskBacklogEmptyPayload(deletedLoopIds));
+        for (const entry of backlogLoops)
+            deleteTaskBacklogLoop(entry, pending);
         updateWidget();
         return backlogLoops.length;
     }
@@ -43,7 +47,7 @@ export function createTaskBacklogRuntime(options) {
             return { entry: existing, created: false };
         const trigger = {
             type: "hybrid",
-            cron: "*/5 * * * *",
+            cron: "*/3 * * * *",
             event: { source: "tasks:created" },
             debounceMs: 30000,
         };

package/dist/scheduler.js

@@ -4,6 +4,9 @@ function computeNextFire(entry) {
     if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid") {
         return cronToNextFire(entry.trigger.type === "hybrid" ? entry.trigger.cron : entry.trigger.schedule);
     }
+    if (entry.trigger.type === "dynamic") {
+        return new Date(entry.dynamic?.nextWakeAt ?? Date.now());
+    }
     return new Date(Date.now() + 60000);
 }
 export class CronScheduler {
@@ -15,10 +18,20 @@ export class CronScheduler {
         this.onFire = onFire;
     }
     start() {
-        for (const entry of this.store.list()) {
+        for (const storedEntry of this.store.list()) {
+            let entry = storedEntry;
             if (entry.status !== "active")
                 continue;
-            if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid") {
+            if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid" || entry.trigger.type === "dynamic") {
+                if (entry.trigger.type === "dynamic" && entry.dynamic?.awaitingUpdate && !this.fireTimes.has(entry.id)) {
+                    entry = this.store.updateDynamic(entry.id, {
+                        dynamic: {
+                            awaitingUpdate: false,
+                            nextWakeAt: undefined,
+                            lastUpdatedAt: Date.now(),
+                        },
+                    }) ?? entry;
+                }
                 this.armTimer(entry);
             }
         }
@@ -27,7 +40,7 @@ export class CronScheduler {
         this.fireTimes.clear();
     }
     add(entry) {
-        if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid") {
+        if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid" || entry.trigger.type === "dynamic") {
             this.armTimer(entry);
         }
     }
@@ -38,11 +51,14 @@ export class CronScheduler {
         return this.fireTimes.get(id);
     }
     armTimer(entry) {
-        const _scheduleExpr = entry.trigger.type === "hybrid" ? entry.trigger.cron : entry.trigger.schedule;
         const nextFire = computeNextFire(entry);
-        const minuteField = _scheduleExpr.trim().split(/\s+/)[0] ?? "";
-        const minuteStep = minuteField.startsWith("*/") ? parseInt(minuteField.slice(2), 10) || 30 : 30;
-        const jitter = computeJitter(entry.id, entry.recurring, minuteStep);
+        let jitter = 0;
+        if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid") {
+            const scheduleExpr = entry.trigger.type === "hybrid" ? entry.trigger.cron : entry.trigger.schedule;
+            const minuteField = scheduleExpr.trim().split(/\s+/)[0] ?? "";
+            const minuteStep = minuteField.startsWith("*/") ? parseInt(minuteField.slice(2), 10) || 30 : 30;
+            jitter = computeJitter(entry.id, entry.recurring, minuteStep);
+        }
         const fireTime = nextFire.getTime() + jitter;
         if (fireTime > entry.expiresAt) {
             this.store.delete(entry.id);
@@ -59,6 +75,8 @@ export class CronScheduler {
                 this.fireTimes.delete(id);
                 continue;
             }
+            if (entry.trigger.type === "dynamic" && entry.dynamic?.awaitingUpdate)
+                continue;
             if (filter && !filter(entry))
                 continue;
             if (now >= entry.expiresAt) {

package/dist/store.d.ts

@@ -1,7 +1,8 @@
 import { type LoopReducerEvent, type LoopReducerState } from "./loop-reducer.js";
 import { ReducerBackedStore } from "./reducer-backed-store.js";
-import type { LoopEntry, LoopStoreData, Trigger } from "./types.js";
+import type { DynamicLoopState, LoopDeletionTombstone, LoopDeletionTombstoneInput, LoopEntry, LoopStoreData, Trigger } from "./types.js";
 export declare class LoopStore extends ReducerBackedStore<LoopEntry, LoopReducerState, LoopReducerEvent, LoopStoreData> {
+    private tombstones;
     constructor(listIdOrPath?: string);
     create(trigger: Trigger, prompt: string, opts: {
         recurring: boolean;
@@ -9,6 +10,7 @@ export declare class LoopStore extends ReducerBackedStore<LoopEntry, LoopReducer
         taskBacklog?: boolean;
         readOnly?: boolean;
         maxFires?: number;
+        dynamic?: Partial<DynamicLoopState>;
     }): LoopEntry;
     pause(id: string): LoopEntry | undefined;
     resume(id: string): LoopEntry | undefined;
@@ -20,6 +22,12 @@ export declare class LoopStore extends ReducerBackedStore<LoopEntry, LoopReducer
         entry: LoopEntry | undefined;
         changedFields: string[];
     };
+    updateDynamic(id: string, fields: {
+        prompt?: string;
+        dynamic: Partial<DynamicLoopState>;
+    }): LoopEntry | undefined;
+    getDeletionTombstone(id: string): LoopDeletionTombstone | undefined;
+    recordDeletionTombstone(id: string, input: LoopDeletionTombstoneInput): LoopDeletionTombstone | undefined;
     delete(id: string): boolean;
     clearExpired(): number;
     expireEventLoops(sessionStartedAt: number): number;

package/dist/store.js

@@ -4,7 +4,9 @@ import { reduceLoopState } from "./loop-reducer.js";
 import { ReducerBackedStore } from "./reducer-backed-store.js";
 const LOOPS_DIR = join(homedir(), ".pi", "loops");
 const MAX_LOOPS = 25;
+const TOMBSTONE_TTL_MS = 10 * 60 * 1000;
 export class LoopStore extends ReducerBackedStore {
+    tombstones = new Map();
     constructor(listIdOrPath) {
         super({
             baseDir: LOOPS_DIR,
@@ -34,6 +36,7 @@ export class LoopStore extends ReducerBackedStore {
                     taskBacklog: opts.taskBacklog,
                     readOnly: opts.readOnly,
                     maxFires: opts.maxFires,
+                    dynamic: opts.dynamic,
                 },
             });
             return this.entries.get(String(this.nextId - 1));
@@ -68,6 +71,22 @@ export class LoopStore extends ReducerBackedStore {
                 entityId: id,
                 payload: { id },
             });
+            if (entry.trigger.type === "dynamic" && entry.dynamic?.awaitingUpdate) {
+                this.applyReducerEvent({
+                    type: "LOOP_DYNAMIC_UPDATED",
+                    at: Date.now(),
+                    source: "tool",
+                    entityType: "loop",
+                    entityId: id,
+                    payload: {
+                        id,
+                        dynamic: {
+                            awaitingUpdate: false,
+                            lastUpdatedAt: Date.now(),
+                        },
+                    },
+                });
+            }
             return this.entries.get(id);
         });
     }
@@ -108,6 +127,44 @@ export class LoopStore extends ReducerBackedStore {
             return { entry: this.entries.get(id), changedFields };
         });
     }
+    updateDynamic(id, fields) {
+        return this.withLock(() => {
+            if (!this.entries.has(id))
+                return undefined;
+            this.applyReducerEvent({
+                type: "LOOP_DYNAMIC_UPDATED",
+                at: Date.now(),
+                source: "tool",
+                entityType: "loop",
+                entityId: id,
+                payload: { id, prompt: fields.prompt, dynamic: fields.dynamic },
+            });
+            return this.entries.get(id);
+        });
+    }
+    getDeletionTombstone(id) {
+        const tombstone = this.tombstones.get(id);
+        if (!tombstone)
+            return undefined;
+        if (Date.now() - tombstone.deletedAt <= TOMBSTONE_TTL_MS)
+            return tombstone;
+        this.tombstones.delete(id);
+        return undefined;
+    }
+    recordDeletionTombstone(id, input) {
+        const entry = this.entries.get(id);
+        if (!entry)
+            return undefined;
+        const tombstone = {
+            id,
+            reason: input.reason,
+            pendingCount: input.pendingCount,
+            deletedAt: Date.now(),
+            prompt: entry.prompt,
+        };
+        this.tombstones.set(id, tombstone);
+        return tombstone;
+    }
     delete(id) {
         return this.withLock(() => {
             if (!this.entries.has(id))

package/dist/tools/loop-tools.d.ts

@@ -11,6 +11,14 @@ interface LoopStoreLike {
         maxFires?: number;
     }): LoopEntry;
     pause(id: string): LoopEntry | undefined;
+    updateDynamic(id: string, fields: {
+        prompt?: string;
+        dynamic: Partial<NonNullable<LoopEntry["dynamic"]>>;
+    }): LoopEntry | undefined;
+    getDeletionTombstone(id: string): {
+        reason: string;
+        pendingCount?: number;
+    } | undefined;
     delete(id: string): boolean;
 }
 interface TriggerSystemLike {