@trevonistrevon/pi-loop 0.6.0 → 0.6.1

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 {

package/dist/tools/loop-tools.js

@@ -1,4 +1,5 @@
 import { Type } from "typebox";
+import { formatTrigger } from "../loop-format.js";
 import { parseInterval } from "../loop-parse.js";
 import { textResult } from "./tool-result.js";
 function validateTrigger(trigger) {
@@ -40,6 +41,67 @@ function formatRemaining(ms) {
         return `${Math.round(ms / 60000)}m`;
     return `${Math.round(ms / 3600000)}h`;
 }
+function parseDelayMs(input) {
+    const match = input.trim().match(/^(\d+)\s*(s|m|h|d)$/i);
+    if (!match)
+        return undefined;
+    const value = Number.parseInt(match[1] ?? "", 10);
+    const unit = (match[2] ?? "").toLowerCase();
+    const multiplier = unit === "s" ? 1000 : unit === "m" ? 60000 : unit === "h" ? 3600000 : 86400000;
+    return value * multiplier;
+}
+function resolveNextWakeAt(nextInterval) {
+    if (!nextInterval)
+        return { nextWakeAt: undefined };
+    const parsedDelayMs = parseDelayMs(nextInterval);
+    if (!parsedDelayMs)
+        return { error: `Invalid nextInterval "${nextInterval}". Use formats like 3m, 30s, or 1h.` };
+    return { nextWakeAt: Date.now() + parsedDelayMs };
+}
+function formatDynamicUpdateResult(id, iteration, nextWakeAt) {
+    const mode = nextWakeAt === undefined
+        ? "Next wake: when idle"
+        : `Next wake: ${formatRemaining(Math.max(0, nextWakeAt - Date.now()))}`;
+    return `Dynamic loop #${id} updated\n` +
+        `Iteration: ${iteration ?? "?"}` +
+        `\n${mode}`;
+}
+function formatDeletionTombstone(id, tombstone) {
+    const detail = tombstone.pendingCount === undefined ? "" : ` (pending: ${tombstone.pendingCount})`;
+    return `Loop #${id} already auto-deleted: ${tombstone.reason}${detail}`;
+}
+function continueDynamicLoop(params, entry, store, triggerSystem) {
+    const { nextWakeAt, error } = resolveNextWakeAt(params.nextInterval);
+    if (error)
+        return error;
+    const updated = store.updateDynamic(params.id, {
+        prompt: params.prompt,
+        dynamic: {
+            goal: params.prompt ?? entry.dynamic.goal,
+            state: params.state,
+            metrics: params.metrics,
+            doneCriteria: params.doneCriteria,
+            iteration: (entry.dynamic.iteration ?? 0) + 1,
+            nextWakeAt,
+            awaitingUpdate: false,
+            lastUpdatedAt: Date.now(),
+        },
+    });
+    if (updated) {
+        triggerSystem.remove(params.id);
+        triggerSystem.add(updated);
+    }
+    return formatDynamicUpdateResult(params.id, updated?.dynamic?.iteration, nextWakeAt);
+}
+function stopDynamicLoop(params, store, triggerSystem) {
+    triggerSystem.remove(params.id);
+    if (params.status === "completed") {
+        store.delete(params.id);
+        return `Dynamic loop #${params.id} completed and deleted`;
+    }
+    store.pause(params.id);
+    return `Dynamic loop #${params.id} paused`;
+}
 export function registerLoopTools(options) {
     const { pi, getStore, getTriggerSystem, getScheduler, getMonitorManager, updateWidget, maybeBootstrapTaskLoop, isTaskSystemReady, } = options;
     pi.registerTool({
@@ -160,11 +222,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
             }
             const bootstrapped = await maybeBootstrapTaskLoop(entry);
             updateWidget();
-            const triggerDesc = trigger.type === "cron"
-                ? `schedule: ${trigger.schedule}`
-                : trigger.type === "event"
-                    ? `event: ${trigger.source}`
-                    : `hybrid: cron ${trigger.cron} + event ${trigger.event.source}`;
+            const triggerDesc = formatTrigger(trigger, "create");
             return Promise.resolve(textResult(`Loop #${entry.id} created: ${entry.prompt.slice(0, 60)}\n` +
                 `Trigger: ${triggerDesc}\n` +
                 `Recurring: ${entry.recurring}\n` +
@@ -188,12 +246,8 @@ Use this before creating new loops to avoid duplicates, or to find IDs for LoopD
                 return Promise.resolve(textResult("No loops configured. Use LoopCreate to set up a schedule."));
             const lines = [];
             for (const entry of loops) {
-                const triggerDesc = entry.trigger.type === "cron"
-                    ? `cron: ${entry.trigger.schedule}`
-                    : entry.trigger.type === "event"
-                        ? `event: ${entry.trigger.source}`
-                        : `hybrid: ${entry.trigger.cron} + ${entry.trigger.event.source}`;
-                const nextFire = entry.trigger.type !== "event" ? getScheduler().nextFire(entry.id) : undefined;
+                const triggerDesc = formatTrigger(entry.trigger, "list");
+                const nextFire = entry.trigger.type === "cron" || entry.trigger.type === "hybrid" || entry.dynamic?.nextWakeAt !== undefined ? getScheduler().nextFire(entry.id) : undefined;
                 const statusIcon = entry.status === "active" ? "*" : entry.status === "paused" ? "-" : "x";
                 let line = `${statusIcon} #${entry.id} [${entry.status}] ${entry.prompt.slice(0, 60)}`;
                 line += ` (${triggerDesc})`;
@@ -210,6 +264,37 @@ Use this before creating new loops to avoid duplicates, or to find IDs for LoopD
             return Promise.resolve(textResult(lines.join("\n")));
         },
     });
+    pi.registerTool({
+        name: "LoopUpdate",
+        label: "LoopUpdate",
+        description: `Update progress for a dynamic loop.
+
+Use this after a dynamic loop wake. Mark status as "continue" with updated state/metrics and optional nextInterval, "completed" when the goal is done, or "paused" to stop temporarily.`,
+        parameters: Type.Object({
+            id: Type.String({ description: "Dynamic loop ID to update" }),
+            status: Type.String({ description: "continue, completed, or paused", enum: ["continue", "completed", "paused"] }),
+            state: Type.Optional(Type.String({ description: "Current progress/state summary" })),
+            metrics: Type.Optional(Type.String({ description: "Current metrics/check results" })),
+            doneCriteria: Type.Optional(Type.String({ description: "Definition of done for the dynamic loop" })),
+            nextInterval: Type.Optional(Type.String({ description: "When to wake next, e.g. 3m, 30s, 1h" })),
+            prompt: Type.Optional(Type.String({ description: "Optional updated goal/prompt text" })),
+        }),
+        execute(_toolCallId, params) {
+            const store = getStore();
+            const triggerSystem = getTriggerSystem();
+            const entry = store.get(params.id);
+            if (!entry)
+                return Promise.resolve(textResult(`Loop #${params.id} not found`));
+            if (entry.trigger.type !== "dynamic" || !entry.dynamic) {
+                return Promise.resolve(textResult(`Loop #${params.id} is not a dynamic loop`));
+            }
+            const message = params.status === "continue"
+                ? continueDynamicLoop(params, entry, store, triggerSystem)
+                : stopDynamicLoop(params, store, triggerSystem);
+            updateWidget();
+            return Promise.resolve(textResult(message));
+        },
+    });
     pi.registerTool({
         name: "LoopDelete",
         label: "LoopDelete",
@@ -224,8 +309,12 @@ Use "pause" to temporarily stop a loop without removing it. Use "delete" to perm
             const { id, action } = params;
             if (action === "pause") {
                 const entry = getStore().pause(id);
-                if (!entry)
+                if (!entry) {
+                    const tombstone = getStore().getDeletionTombstone(id);
+                    if (tombstone)
+                        return Promise.resolve(textResult(formatDeletionTombstone(id, tombstone)));
                     return Promise.resolve(textResult(`Loop #${id} not found`));
+                }
                 getTriggerSystem().remove(id);
                 updateWidget();
                 return Promise.resolve(textResult(`Loop #${id} paused`));
@@ -235,6 +324,9 @@ Use "pause" to temporarily stop a loop without removing it. Use "delete" to perm
             updateWidget();
             if (deleted)
                 return Promise.resolve(textResult(`Loop #${id} deleted`));
+            const tombstone = getStore().getDeletionTombstone(id);
+            if (tombstone)
+                return Promise.resolve(textResult(formatDeletionTombstone(id, tombstone)));
             return Promise.resolve(textResult(`Loop #${id} not found`));
         },
     });

package/dist/trigger-system.js

@@ -28,7 +28,7 @@ export class TriggerSystem {
         this.hybridTimers.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.scheduler.add(entry);
         }
         if (entry.trigger.type === "event" || entry.trigger.type === "hybrid") {

package/dist/types.d.ts

@@ -1,3 +1,12 @@
+export type LoopDeletionReason = "task_backlog_empty";
+export interface LoopDeletionTombstone {
+    id: string;
+    reason: LoopDeletionReason;
+    deletedAt: number;
+    prompt: string;
+    pendingCount?: number;
+}
+export type LoopDeletionTombstoneInput = Omit<LoopDeletionTombstone, "id" | "deletedAt" | "prompt">;
 export type LoopStatus = "active" | "paused";
 export interface CronTrigger {
     type: "cron";
@@ -17,7 +26,20 @@ export interface HybridTrigger {
     };
     debounceMs: number;
 }
-export type Trigger = CronTrigger | EventTrigger | HybridTrigger;
+export interface DynamicTrigger {
+    type: "dynamic";
+}
+export type Trigger = CronTrigger | EventTrigger | HybridTrigger | DynamicTrigger;
+export interface DynamicLoopState {
+    goal: string;
+    state?: string;
+    metrics?: string;
+    doneCriteria?: string;
+    iteration: number;
+    nextWakeAt?: number;
+    awaitingUpdate?: boolean;
+    lastUpdatedAt?: number;
+}
 export interface LoopEntry {
     id: string;
     prompt: string;
@@ -32,6 +54,7 @@ export interface LoopEntry {
     readOnly?: boolean;
     maxFires?: number;
     fireCount?: number;
+    dynamic?: DynamicLoopState;
 }
 export interface LoopStoreData {
     nextId: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trevonistrevon/pi-loop",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "A pi extension for cron/event-based agent re-wake loops and background process monitoring.",
   "author": "trevonistrevon",
   "license": "MIT",
@@ -17,6 +17,13 @@
     "monitor",
     "scheduler"
   ],
+  "files": [
+    "src/",
+    "dist/",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
   "exports": {
     ".": "./src/index.ts",
     "./api": "./src/api.ts",
@@ -30,7 +37,8 @@
     "typebox": "^1.1.34"
   },
   "scripts": {
-    "build": "tsc",
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "npm run clean && tsc",
     "prepublishOnly": "npm run lint && npm run typecheck && npm run test && npm run build",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",