@trevonistrevon/pi-loop 0.6.0 → 0.6.1

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.6.1](https://github.com/trvon/pi-loop/compare/pi-loop-v0.6.0...pi-loop-v0.6.1) (2026-07-16)
+
+
+### Features
+
+* **loop:** add dynamic goal loops ([44e578f](https://github.com/trvon/pi-loop/commit/44e578f5e7cdeaf6aee765835892dd975d2fe913))
+
+
+### Bug Fixes
+
+* fast failing monitor hit error before onDone registered. Orca/agent never woke. ([56cd43d](https://github.com/trvon/pi-loop/commit/56cd43d2b41a6b0df5c10cccb11c0fa04981d83a))
+* **loop:** harden dynamic goal loops ([036fbaf](https://github.com/trvon/pi-loop/commit/036fbaff9a8c7c60acefce4dec757bfc1e6ff8d0))
+
 ## [0.6.0](https://github.com/trvon/pi-loop/compare/pi-loop-v0.5.8...pi-loop-v0.6.0) (2026-07-02)
 
 

package/README.md

@@ -1,6 +1,6 @@
 <p align="center">
 <h1 align="center">@trevonistrevon/pi-loop</h1>
-<h6 align="center">Cron and event loops for the pi coding agent. Background monitors, scheduled re-wakes, pi-tasks integration, and native task fallback.</h6>
+<h6 align="center">Cron, event, and dynamic goal loops for the pi coding agent. Background monitors, scheduled re-wakes, pi-tasks integration, and native task fallback.</h6>
 </p>
 
 ## Install
@@ -36,13 +36,24 @@ TaskDelete id="1"
 
 ## Commands
 
-`/loop [interval] [prompt]` — interactive loop creation.
+`/loop` creates scheduled, event-triggered, or self-paced dynamic goal loops.
 
 ```text
-/loop                         # menu
-/loop 5m check the deploy     # 5-minute cron loop
+/loop                                      # menu
+/loop 5m check the deploy                  # 5-minute cron loop
+/loop event tasks:created process backlog  # event loop
+/loop finish the release                   # dynamic goal loop
 ```
 
+Dynamic goal loops wake immediately when the agent is idle. After each iteration, the agent calls `LoopUpdate` with one of:
+
+- `status="continue"` to save progress and wake again when idle
+- `status="continue" nextInterval="3m"` to schedule a timed next wake
+- `status="paused"` when blocked
+- `status="completed"` to finish and delete the loop
+
+Paused dynamic loops can be resumed from the `/loop` menu. Dynamic loops recover their wake after a process restart or session switch if an in-memory notification was lost.
+
 `/tasks` — interactive native task viewer/manager, only registered when `pi-tasks` is absent.
 
 ```text
@@ -56,6 +67,7 @@ TaskDelete id="1"
 |---|---|
 | `LoopCreate` | Schedule a prompt on a cron timer, a pi event, or both with debounce |
 | `LoopList` | Show active loops with IDs, triggers, and next-fire times |
+| `LoopUpdate` | Continue, pause, or complete a dynamic goal loop and save its progress |
 | `LoopDelete` | Delete or pause a loop |
 | `MonitorCreate` | Run a background command, stream output as `monitor:output` events. Use `onDone` for auto-notify on completion |
 | `MonitorList` | Show monitors with status, uptime, and output line count |
@@ -65,7 +77,7 @@ TaskDelete id="1"
 | `TaskUpdate` | Update native fallback task status/details |
 | `TaskDelete` | Delete a native fallback task |
 
-Trigger types: `cron` (`5m`, `1h`, `0 9 * * 1-5`), `event` (any pi event source), or `hybrid` (both, debounced).
+Trigger types: `cron` (`5m`, `1h`, `0 9 * * 1-5`), `event` (any pi event source), `hybrid` (both, debounced), or `dynamic` (self-paced goal loops created with `/loop <goal>`).
 
 ## Tasks
 

package/dist/commands/loop-command.d.ts

@@ -1,9 +1,16 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { LoopEntry, Trigger } from "../types.js";
+import type { DynamicLoopState, LoopEntry, Trigger } from "../types.js";
 interface LoopStoreLike {
     list(): LoopEntry[];
     get(id: string): LoopEntry | undefined;
-    create(trigger: Trigger, prompt: string, options?: Partial<LoopEntry>): LoopEntry;
+    create(trigger: Trigger, prompt: string, options: {
+        recurring: boolean;
+        autoTask?: boolean;
+        taskBacklog?: boolean;
+        readOnly?: boolean;
+        maxFires?: number;
+        dynamic?: Partial<DynamicLoopState>;
+    }): LoopEntry;
     pause(id: string): LoopEntry | undefined;
     resume(id: string): LoopEntry | undefined;
     delete(id: string): boolean;

package/dist/commands/loop-command.js

@@ -1,30 +1,69 @@
-import { parseInterval } from "../loop-parse.js";
+import { formatTrigger } from "../loop-format.js";
+import { isValidCronExpression, parseInterval } from "../loop-parse.js";
+function parseLoopCommandRoute(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return { type: "menu" };
+    const eventMatch = trimmed.match(/^(?:event|when)\s+(\S+)\s+(.+)$/i);
+    if (eventMatch?.[1] && eventMatch[2]) {
+        return { type: "event", source: eventMatch[1], prompt: eventMatch[2].trim() };
+    }
+    const parts = trimmed.split(/\s+/);
+    if (parts.length > 5) {
+        const interval = parts.slice(0, 5).join(" ");
+        const cronShaped = parts.slice(0, 5).every((part) => /^[\d*/,-]+$/.test(part));
+        if (cronShaped) {
+            if (!isValidCronExpression(interval))
+                return { type: "invalid-cron", interval };
+            return { type: "cron", interval, prompt: parts.slice(5).join(" "), notifyEvery: false };
+        }
+    }
+    const intervalMatch = trimmed.match(/^(\d+\s*[smhdS]\b)/i);
+    if (intervalMatch) {
+        const interval = intervalMatch[1] ?? intervalMatch[0];
+        const prompt = trimmed.slice(intervalMatch[0].length).trim();
+        if (!prompt)
+            return { type: "missing-interval-prompt" };
+        return { type: "cron", interval, prompt, notifyEvery: true };
+    }
+    return { type: "dynamic", goal: trimmed };
+}
 export function registerLoopCommand(options) {
     const { pi, getStore, getTriggerSystem, updateWidget } = options;
-    async function scheduleLoop(ui, prompt) {
-        const p = prompt || await ui.input("Prompt (what should the agent check?)");
-        if (!p)
-            return;
-        const interval = await ui.input("Interval (e.g., 5m, 2h, 1d)");
-        if (!interval)
-            return;
+    function createCronLoop(ui, interval, prompt, notifyEvery) {
+        let entry;
         try {
             const parsed = parseInterval(interval);
             const trigger = { type: "cron", schedule: parsed.cron };
-            const entry = getStore().create(trigger, p, { recurring: true });
+            entry = getStore().create(trigger, prompt, { recurring: true });
             getTriggerSystem().add(entry);
             updateWidget();
-            ui.notify(`Loop #${entry.id} created: every ${parsed.description}`, "info");
+            const cadence = notifyEvery ? `every ${parsed.description}` : parsed.description;
+            ui.notify(`Loop #${entry.id} created: ${cadence} — ${prompt.slice(0, 50)}`, "info");
         }
         catch (err) {
+            if (entry) {
+                getTriggerSystem().remove(entry.id);
+                getStore().delete(entry.id);
+                updateWidget();
+            }
             ui.notify(err.message, "error");
         }
     }
-    async function eventLoop(ui, prompt) {
+    async function scheduleLoop(ui, prompt) {
+        const p = prompt || await ui.input("Prompt (what should the agent check?)");
+        if (!p)
+            return;
+        const interval = await ui.input("Interval (e.g., 5m, 2h, 1d)");
+        if (!interval)
+            return;
+        createCronLoop(ui, interval, p, true);
+    }
+    async function eventLoop(ui, prompt, sourceOverride) {
         const p = prompt || await ui.input("Prompt");
         if (!p)
             return;
-        const source = await ui.input("Pi event source (e.g., tool_execution_start, before_agent_start)");
+        const source = sourceOverride || await ui.input("Pi event source (e.g., tool_execution_start, before_agent_start)");
         if (!source)
             return;
         const trigger = { type: "event", source };
@@ -33,6 +72,17 @@ export function registerLoopCommand(options) {
         updateWidget();
         ui.notify(`Event loop #${entry.id} created: fires on "${source}"`, "info");
     }
+    function dynamicLoop(ui, goal) {
+        const trigger = { type: "dynamic" };
+        const entry = getStore().create(trigger, goal, {
+            recurring: true,
+            maxFires: 20,
+            dynamic: { goal, iteration: 0 },
+        });
+        getTriggerSystem().add(entry);
+        updateWidget();
+        ui.notify(`Dynamic loop #${entry.id} created — ${goal.slice(0, 50)}`, "info");
+    }
     async function viewLoops(ui) {
         const loops = getStore().list();
         if (loops.length === 0) {
@@ -41,12 +91,7 @@ export function registerLoopCommand(options) {
         }
         const choices = loops.map((l) => {
             const icon = l.status === "active" ? "*" : l.status === "paused" ? "-" : "x";
-            const triggerDesc = l.trigger.type === "cron"
-                ? `cron: ${l.trigger.schedule}`
-                : l.trigger.type === "event"
-                    ? `event: ${l.trigger.source}`
-                    : `hybrid: ${l.trigger.cron}`;
-            return `${icon} #${l.id} [${l.status}] ${l.prompt.slice(0, 50)} (${triggerDesc})`;
+            return `${icon} #${l.id} [${l.status}] ${l.prompt.slice(0, 50)} (${formatTrigger(l.trigger, "command")})`;
         });
         choices.push("< Back");
         const selected = await ui.select("Loops", choices);
@@ -76,8 +121,10 @@ export function registerLoopCommand(options) {
                     ui.notify(`Loop #${entry.id} paused`, "info");
                 }
                 else if (action === "* Resume") {
-                    getStore().resume(entry.id);
-                    getTriggerSystem().add(entry);
+                    const resumed = getStore().resume(entry.id);
+                    if (!resumed)
+                        return viewLoops(ui);
+                    getTriggerSystem().add(resumed);
                     updateWidget();
                     ui.notify(`Loop #${entry.id} resumed`, "info");
                 }
@@ -91,11 +138,11 @@ export function registerLoopCommand(options) {
         ui.notify(`${active}/${loops.length} active loops (max 25)`, "info");
     }
     pi.registerCommand("loop", {
-        description: "Create a repeating scheduled task: /loop [interval] [prompt]. E.g., /loop 5m check the deploy, /loop 30s am I still here",
+        description: "Create a loop. Use /loop [interval] [prompt] for scheduled loops, /loop event <source> <prompt> for event loops, or /loop <goal> for a dynamic goal loop.",
         handler: async (args, ctx) => {
-            const trimmed = args.trim();
             const ui = ctx.ui;
-            if (!trimmed) {
+            const route = parseLoopCommandRoute(args);
+            if (route.type === "menu") {
                 const choice = await ui.select("Loop", [
                     "Create scheduled loop",
                     "Create event-triggered loop",
@@ -112,36 +159,19 @@ export function registerLoopCommand(options) {
                     return viewLoops(ui);
                 return settings(ui);
             }
-            const intervalMatch = trimmed.match(/^(\d+\s*[smhdS]\b)/i);
-            if (intervalMatch) {
-                const interval = intervalMatch[1] ?? intervalMatch[0];
-                const prompt = trimmed.slice(intervalMatch[0].length).trim();
-                if (!prompt) {
-                    ui.notify("Provide a prompt after the interval, e.g., /loop 5m check the deploy", "warning");
-                    return;
-                }
-                try {
-                    const parsed = parseInterval(interval);
-                    const trigger = { type: "cron", schedule: parsed.cron };
-                    const entry = getStore().create(trigger, prompt, { recurring: true });
-                    getTriggerSystem().add(entry);
-                    updateWidget();
-                    ui.notify(`Loop #${entry.id} created: every ${parsed.description} — ${prompt.slice(0, 50)}`, "info");
-                }
-                catch (err) {
-                    ui.notify(err.message, "error");
-                }
+            if (route.type === "event")
+                return eventLoop(ui, route.prompt, route.source);
+            if (route.type === "cron")
+                return createCronLoop(ui, route.interval, route.prompt, route.notifyEvery);
+            if (route.type === "invalid-cron") {
+                ui.notify(`Invalid cron expression: ${route.interval}`, "error");
                 return;
             }
-            const choice = await ui.select("Loop mode", [
-                `Scheduled: "${trimmed.slice(0, 50)}"`,
-                `Event-triggered: "${trimmed.slice(0, 50)}"`,
-            ]);
-            if (!choice)
+            if (route.type === "missing-interval-prompt") {
+                ui.notify("Provide a prompt after the interval, e.g., /loop 5m check the deploy", "warning");
                 return;
-            if (choice.startsWith("Event"))
-                return eventLoop(ui, trimmed);
-            return scheduleLoop(ui, trimmed);
+            }
+            return dynamicLoop(ui, route.goal);
         },
     });
 }

package/dist/index.d.ts

@@ -4,13 +4,14 @@
  * Tools:
  *   LoopCreate    — Create a scheduled or event-triggered re-wake loop
  *   LoopList      — List all active loops with status and next-fire times
+ *   LoopUpdate    — Continue, pause, or complete a dynamic goal loop
  *   LoopDelete    — Delete or pause a loop by ID
  *   MonitorCreate — Start a background command that streams output via pi events
  *   MonitorList   — List running monitors
  *   MonitorStop   — Stop a running monitor
  *
  * Commands:
- *   /loop    — Schedule or manage re-wake loops: /loop [interval] [prompt]
+ *   /loop    — Schedule or manage re-wake loops, including /loop <goal>
  *   /tasks   — View or manage native fallback tasks when pi-tasks is absent
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";

package/dist/index.js

@@ -4,13 +4,14 @@
  * Tools:
  *   LoopCreate    — Create a scheduled or event-triggered re-wake loop
  *   LoopList      — List all active loops with status and next-fire times
+ *   LoopUpdate    — Continue, pause, or complete a dynamic goal loop
  *   LoopDelete    — Delete or pause a loop by ID
  *   MonitorCreate — Start a background command that streams output via pi events
  *   MonitorList   — List running monitors
  *   MonitorStop   — Stop a running monitor
  *
  * Commands:
- *   /loop    — Schedule or manage re-wake loops: /loop [interval] [prompt]
+ *   /loop    — Schedule or manage re-wake loops, including /loop <goal>
  *   /tasks   — View or manage native fallback tasks when pi-tasks is absent
  */
 import { registerLoopCommand } from "./commands/loop-command.js";
@@ -58,15 +59,25 @@ export default function (pi) {
         // detection window is a shadow — never surface it in the status line.
         if (tasksAvailable || !nativeTaskStore)
             return { count: 0 };
-        const tasks = nativeTaskStore.list().filter(t => t.status === "pending" || t.status === "in_progress");
-        const active = tasks.find(t => t.status === "in_progress");
-        const next = tasks.find(t => t.status === "pending");
-        const focus = active
-            ? `active: ${active.subject.slice(0, 50)}`
-            : next
-                ? `next: ${next.subject.slice(0, 50)}`
+        let count = 0;
+        let activeSubject;
+        let nextSubject;
+        for (const task of nativeTaskStore.list()) {
+            if (task.status === "in_progress") {
+                count++;
+                activeSubject ??= task.subject;
+            }
+            else if (task.status === "pending") {
+                count++;
+                nextSubject ??= task.subject;
+            }
+        }
+        const focus = activeSubject
+            ? `active: ${activeSubject.slice(0, 50)}`
+            : nextSubject
+                ? `next: ${nextSubject.slice(0, 50)}`
                 : undefined;
-        return { count: tasks.length, focusText: focus };
+        return { count, focusText: focus };
     });
     scheduler = new CronScheduler(store, onLoopFire);
     triggerSystem = new TriggerSystem(pi, scheduler, store, onLoopFire);
@@ -180,6 +191,9 @@ export default function (pi) {
         deleteLoop: (id) => {
             store.delete(id);
         },
+        recordDeletionTombstone: (id, tombstone) => {
+            store.recordDeletionTombstone(id, tombstone);
+        },
         addTrigger: (entry) => {
             triggerSystem.add(entry);
         },
@@ -213,6 +227,16 @@ export default function (pi) {
             return;
         }
         store.fire(entry.id);
+        const firedAt = Date.now();
+        const firedEntry = entry.trigger.type === "dynamic"
+            ? store.updateDynamic(entry.id, {
+                dynamic: {
+                    awaitingUpdate: true,
+                    nextWakeAt: undefined,
+                    lastUpdatedAt: firedAt,
+                },
+            }) ?? entry
+            : entry;
         if (entry.autoTask) {
             autoCreateTask(entry).then((taskId) => {
                 if (taskId)
@@ -220,13 +244,14 @@ export default function (pi) {
             });
         }
         pi.events.emit("loop:fire", {
-            loopId: entry.id,
-            prompt: entry.prompt,
-            trigger: entry.trigger,
-            timestamp: Date.now(),
-            readOnly: entry.readOnly,
-            recurring: entry.recurring,
-            autoTask: entry.autoTask,
+            loopId: firedEntry.id,
+            prompt: firedEntry.prompt,
+            trigger: firedEntry.trigger,
+            timestamp: firedAt,
+            readOnly: firedEntry.readOnly,
+            recurring: firedEntry.recurring,
+            autoTask: firedEntry.autoTask,
+            dynamic: firedEntry.dynamic,
         });
     }
     // ── Session lifecycle ──

package/dist/loop-format.d.ts

@@ -0,0 +1,3 @@
+import type { Trigger } from "./types.js";
+export type TriggerFormatStyle = "command" | "create" | "list" | "notification";
+export declare function formatTrigger(trigger: Trigger | string, style?: TriggerFormatStyle): string;

package/dist/loop-format.js

@@ -0,0 +1,20 @@
+export function formatTrigger(trigger, style = "list") {
+    if (typeof trigger === "string")
+        return trigger;
+    if (trigger.type === "cron") {
+        return style === "create" || style === "notification"
+            ? `schedule: ${trigger.schedule}`
+            : `cron: ${trigger.schedule}`;
+    }
+    if (trigger.type === "event")
+        return `event: ${trigger.source}`;
+    if (trigger.type === "dynamic")
+        return "dynamic";
+    if (style === "command")
+        return `hybrid: ${trigger.cron}`;
+    if (style === "create")
+        return `hybrid: cron ${trigger.cron} + event ${trigger.event.source}`;
+    if (style === "notification")
+        return "hybrid";
+    return `hybrid: ${trigger.cron} + ${trigger.event.source}`;
+}

package/dist/loop-parse.d.ts

@@ -1,3 +1,4 @@
+export declare function isValidCronExpression(expr: string): boolean;
 export declare function parseInterval(input: string): {
     cron: string;
     description: string;

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.js

@@ -246,7 +246,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;