@trevonistrevon/pi-loop 0.5.9 → 0.6.1

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,8 +1,7 @@
 import { Type } from "typebox";
+import { formatTrigger } from "../loop-format.js";
 import { parseInterval } from "../loop-parse.js";
-function textResult(msg) {
-    return { content: [{ type: "text", text: msg }], details: undefined };
-}
+import { textResult } from "./tool-result.js";
 function validateTrigger(trigger) {
     if (trigger.type === "cron") {
         const parts = trigger.schedule.trim().split(/\s+/);
@@ -42,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({
@@ -162,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` +
@@ -190,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})`;
@@ -212,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",
@@ -226,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`));
@@ -237,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/tools/monitor-tools.js

@@ -1,7 +1,5 @@
 import { Type } from "typebox";
-function textResult(msg) {
-    return { content: [{ type: "text", text: msg }], details: undefined };
-}
+import { textResult } from "./tool-result.js";
 function formatRemaining(ms) {
     if (ms < 60000)
         return `${Math.round(ms / 1000)}s`;

package/dist/tools/native-task-tools.d.ts

@@ -1,11 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type TaskBacklogResult } from "../runtime/task-mutations.js";
 import { TaskStore } from "../task-store.js";
-export interface TaskBacklogResult {
-    created: boolean;
-    entry?: {
-        id: string;
-    };
-}
+export type { TaskBacklogResult };
 export interface NativeTaskToolsOptions {
     pi: ExtensionAPI;
     taskStore: TaskStore;

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

@@ -1,10 +1,14 @@
 import { Type } from "typebox";
-import { emitNativeTaskEvent } from "../runtime/task-events.js";
-function textResult(msg) {
-    return { content: [{ type: "text", text: msg }], details: undefined };
+import { createTask, deleteTask, updateTask, } from "../runtime/task-mutations.js";
+import { textResult } from "./tool-result.js";
+function backlogSuffix(backlog) {
+    return backlog.created && backlog.entry
+        ? `\nBacklog worker loop #${backlog.entry.id} created`
+        : "";
 }
 export function registerNativeTaskTools(options) {
     const { pi, taskStore, evaluateTaskBacklog, updateWidget } = options;
+    const mutationCtx = { pi, taskStore, evaluateTaskBacklog, updateWidget };
     pi.registerTool({
         name: "TaskCreate",
         label: "TaskCreate",
@@ -30,14 +34,11 @@ Fields:
             description: Type.String({ description: "Detailed description of what needs to be done" }),
         }),
         async execute(_toolCallId, params) {
-            const entry = taskStore.create(params.subject, params.description);
-            emitNativeTaskEvent(pi, "tasks:created", entry);
-            const backlog = await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
-            updateWidget();
-            const autoLoopMsg = backlog.created && backlog.entry
-                ? `\nBacklog worker loop #${backlog.entry.id} created`
-                : "";
-            return Promise.resolve(textResult(`Task #${entry.id} created: ${entry.subject}${autoLoopMsg}`));
+            const { entry, backlog } = await createTask(mutationCtx, {
+                subject: params.subject,
+                description: params.description,
+            });
+            return textResult(`Task #${entry.id} created: ${entry.subject}${backlogSuffix(backlog)}`);
         },
     });
     pi.registerTool({
@@ -84,41 +85,16 @@ Parameters: id (required), status, subject, description`,
         }),
         async execute(_toolCallId, params) {
             const { id, status, subject, description } = params;
-            let entry = taskStore.get(id);
-            if (!entry)
-                return Promise.resolve(textResult(`Task #${id} not found`));
-            const previousStatus = entry.status;
-            if (status === "in_progress") {
-                entry = taskStore.start(id);
-                if (entry)
-                    emitNativeTaskEvent(pi, "tasks:started", entry, previousStatus);
-            }
-            else if (status === "completed") {
-                entry = taskStore.complete(id);
-                if (entry)
-                    emitNativeTaskEvent(pi, "tasks:completed", entry, previousStatus);
-            }
-            else if (status === "pending") {
-                entry = taskStore.reopen(id);
-                if (entry)
-                    emitNativeTaskEvent(pi, "tasks:reopened", entry, previousStatus);
-            }
-            if (!entry)
-                return Promise.resolve(textResult(`Task #${id} not found`));
-            if (subject !== undefined || description !== undefined) {
-                entry = taskStore.updateDetails(id, { subject, description });
-                if (entry)
-                    emitNativeTaskEvent(pi, "tasks:updated", entry, previousStatus);
-            }
-            if (!entry)
-                return Promise.resolve(textResult(`Task #${id} not found`));
-            updateWidget();
-            const backlog = await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
+            const result = await updateTask(mutationCtx, {
+                id,
+                status: status,
+                subject,
+                description,
+            });
+            if (!result)
+                return textResult(`Task #${id} not found`);
             const statusMsg = status ? ` → ${status}` : "";
-            const autoLoopMsg = backlog.created && backlog.entry
-                ? `\nBacklog worker loop #${backlog.entry.id} created`
-                : "";
-            return Promise.resolve(textResult(`Task #${id} updated${statusMsg}${autoLoopMsg}`));
+            return textResult(`Task #${id} updated${statusMsg}${backlogSuffix(result.backlog)}`);
         },
     });
     pi.registerTool({
@@ -129,16 +105,10 @@ Parameters: id (required), status, subject, description`,
             id: Type.String({ description: "Task ID to delete" }),
         }),
         async execute(_toolCallId, params) {
-            const existing = taskStore.get(params.id);
-            const deleted = taskStore.delete(params.id);
-            updateWidget();
-            if (deleted) {
-                if (existing)
-                    emitNativeTaskEvent(pi, "tasks:deleted", existing, existing.status);
-                await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
-                return Promise.resolve(textResult(`Task #${params.id} deleted`));
-            }
-            return Promise.resolve(textResult(`Task #${params.id} not found`));
+            const result = await deleteTask(mutationCtx, params.id);
+            if (!result)
+                return textResult(`Task #${params.id} not found`);
+            return textResult(`Task #${params.id} deleted`);
         },
     });
 }

package/dist/tools/tool-result.d.ts

@@ -0,0 +1,8 @@
+/** Plain-text tool result in the shape pi's registerTool expects. */
+export declare function textResult(msg: string): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: undefined;
+};

package/dist/tools/tool-result.js

@@ -0,0 +1,4 @@
+/** Plain-text tool result in the shape pi's registerTool expects. */
+export function textResult(msg) {
+    return { content: [{ type: "text", text: msg }], details: undefined };
+}

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.5.9",
+  "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,18 @@
     "monitor",
     "scheduler"
   ],
+  "files": [
+    "src/",
+    "dist/",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": "./src/index.ts",
+    "./api": "./src/api.ts",
+    "./package.json": "./package.json"
+  },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.75.5",
     "@earendil-works/pi-tui": "^0.75.5"
@@ -25,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",

package/src/api.ts

@@ -0,0 +1,36 @@
+/**
+ * Public API surface for sibling extensions (imported as
+ * `@trevonistrevon/pi-loop/api`). Everything else under src/ is internal —
+ * the package `exports` map deliberately blocks deep imports.
+ */
+export {
+  type CleanReply,
+  type CreateTaskParams,
+  type CreateTaskReply,
+  type PendingReply,
+  type PingReply,
+  replyChannel,
+  type SpawnParams,
+  type SpawnReply,
+  SUBAGENTS_RPC,
+  TASK_EVENTS,
+  TASKS_RPC,
+  type TaskEntryWire,
+  type TaskStatusWire,
+  type UpdateTaskParams,
+  type UpdateTaskReply,
+} from "./rpc/channels.js";
+export {
+  type HandleRpcOptions,
+  handleRpc,
+  PROTOCOL_VERSION,
+  RpcError,
+  type RpcEventBus,
+  type RpcReply,
+  rpcCall,
+  rpcProbe,
+} from "./rpc/cross-extension-rpc.js";
+export { NATIVE_TASKS_PROVIDER } from "./runtime/native-task-rpc.js";
+export { resolveLoopStorePath, resolveTaskStorePath } from "./runtime/scope.js";
+export { TaskStore } from "./task-store.js";
+export type { TaskEntry, TaskStatus, TaskStoreData } from "./task-types.js";