@trevonistrevon/pi-loop 0.6.0 → 0.6.2

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [0.6.2](https://github.com/trvon/pi-loop/compare/pi-loop-v0.6.1...pi-loop-v0.6.2) (2026-07-17)
+
+
+### Bug Fixes
+
+* **deps:** require patched pi runtime ([459a44a](https://github.com/trvon/pi-loop/commit/459a44af75dce174e53d70ef0427ca773845a912))
+* **loop:** start dynamic goals immediately ([790959c](https://github.com/trvon/pi-loop/commit/790959c02d3c2b301526f780122aacf533429bc5))
+* **monitor:** wake after timeouts ([478535b](https://github.com/trvon/pi-loop/commit/478535b3c837e74074dc022ea35ec3ba9b18f533))
+
+## [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">Scheduled and event-driven agent re-wakes for pi, with dynamic goals and background process monitoring.</h6>
 </p>
 
 ## Install
@@ -11,165 +11,50 @@ pi install npm:@trevonistrevon/pi-loop
 
 ## Quick start
 
-```text
-LoopCreate trigger="5m" prompt="Check if the build passed"
-LoopCreate trigger="tool_execution_start" prompt="Log the tool being used" triggerType="event"
-LoopList
-LoopDelete id="1"
-```
+Create scheduled, event-driven, or self-paced loops:
 
 ```text
-MonitorCreate command="tail -n0 -f build.log" description="Watch build"
-MonitorCreate command="python train.py" onDone="Analyze results and report best loss"
-MonitorList
-MonitorStop monitorId="1"
+/loop 5m check the deploy
+/loop event tasks:created process the backlog
+/loop finish the release
 ```
 
-When `pi-tasks` is not installed, `pi-loop` also exposes native task tools after startup detection:
+Or use the tools directly:
 
 ```text
-TaskCreate subject="Fix deploy polling" description="Switch deploy check to event-driven loop"
-TaskList
-TaskUpdate id="1" status="in_progress"
-TaskDelete id="1"
+LoopCreate trigger="5m" prompt="Check if the build passed" maxFires=12
+LoopCreate trigger="tool_execution_start" prompt="Log the tool" triggerType="event" recurring=true
+LoopList
+LoopDelete id="1"
 ```
 
-## Commands
-
-`/loop [interval] [prompt]` — interactive loop creation.
+Run work in the background and wake the agent when it succeeds, fails, or times out:
 
 ```text
-/loop                         # menu
-/loop 5m check the deploy     # 5-minute cron loop
+MonitorCreate command="python train.py" onDone="Analyze results and report best loss"
+MonitorList
+MonitorStop monitorId="1"
 ```
 
-`/tasks` — interactive native task viewer/manager, only registered when `pi-tasks` is absent.
+## What it provides
 
-```text
-/tasks                        # open native task viewer
-/tasks Write README updates   # quick-create native task
-```
+- Cron, event, hybrid, and dynamic goal loops
+- Idle-safe agent re-wakes with dynamic-loop restart/session-switch recovery
+- Background command monitoring with buffered output and `onDone` wakes
+- Optional `pi-tasks` integration and a native task fallback
+- Session-isolated persistence and a compact TUI status line
 
-## Tools
+## Commands and tools
 
-| Tool | What it does |
+| Surface | Purpose |
 |---|---|
-| `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 |
-| `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 |
-| `MonitorStop` | Stop a monitor (SIGTERM → 5s → SIGKILL) |
-| `TaskCreate` | Create a native fallback task when `pi-tasks` is absent |
-| `TaskList` | List native fallback tasks |
-| `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).
-
-## Tasks
-
-### With `pi-tasks`
-
-Works with [@tintinweb/pi-tasks](https://github.com/tintinweb/pi-tasks). Pass `autoTask: true` on `LoopCreate` and each loop fire auto-creates a tracked task. Detection happens over pi's event bus — no manual wiring.
-
-### Without `pi-tasks`
-
-If `pi-tasks` does not respond during startup detection, `pi-loop` registers a native fallback task system for the session:
-
-- session- or project-scoped task files under `.pi/tasks/` depending on `PI_LOOP_SCOPE`
-- `TaskCreate`, `TaskList`, `TaskUpdate`, `TaskDelete`
-- `/tasks` interactive viewer
-- compact status-line task tracking
-- native task RPC replies on `tasks:rpc:ping`, `tasks:rpc:create`, `tasks:rpc:pending`, `tasks:rpc:clean`, and `tasks:rpc:update`
-
-This fallback is session-sticky: `pi-loop` decides once at startup whether `pi-tasks` or native tasks own task management for that session.
-
-### Task and backlog events
-
-`pi-loop` emits native task lifecycle events that other extensions can consume directly:
-
-- `tasks:created`
-- `tasks:started`
-- `tasks:completed`
-- `tasks:reopened`
-- `tasks:updated`
-- `tasks:deleted`
-
-Payloads carry `previousStatus`. Transition events (`tasks:started` /
-`tasks:completed` / `tasks:reopened`) report the status before the transition;
-`tasks:updated` (a details edit) reports the status current at edit time — so a
-combined status+details update never fabricates a second transition. (Changed
-in 0.6.0: the tool path previously reused the pre-transition status.)
-- `tasks:backlog_empty` — emitted when a task-backlog worker observes zero pending tasks and is about to auto-delete
-- `loops:autodeleted` — emitted for each loop that `pi-loop` auto-deletes, including backlog workers removed because the task queue drained
-
-### Cross-extension task RPC
-
-Other extensions can create and manage native tasks without importing `pi-loop` internals. `pi-loop` answers `ping` over `pi.events` from extension init; the other verbs unlock once the pi-tasks detection probe settles (a few seconds at most, immediate when no provider replies race it). The whole server stands down (silent no-op) once an external `pi-tasks` is detected:
-
-| Channel | Request | Reply |
-|---|---|---|
-| `tasks:rpc:ping` | `{}` | `{ version, provider }` |
-| `tasks:rpc:pending` | `{}` | `{ pending }` |
-| `tasks:rpc:create` | `{ subject, description, metadata? }` | `{ id, task }` |
-| `tasks:rpc:clean` | `{}` | `{ pruned }` |
-| `tasks:rpc:update` | `{ id, status?, subject?, description? }` | `{ task }` |
-
-Every request/reply pair follows the same contract: emit `{ requestId, ...params }` on the channel, receive an envelope on `<channel>:reply:<requestId>` — `{ success: true, data }` or `{ success: false, error }`.
-
-`@trevonistrevon/pi-loop/api` exports typed channel constants and a client helper so consumers don't hand-roll the envelope:
-
-```ts
-import { TASKS_RPC, rpcCall } from "@trevonistrevon/pi-loop/api";
-
-const { id, task } = await rpcCall(pi.events, TASKS_RPC.create, {
-  subject: "Fix deploy polling",
-  description: "Switch deploy check to event-driven loop",
-});
-```
-
-`rpcCall` rejects on failure or timeout instead of returning a sentinel; wrap it in `try/catch` if you want fallback behavior. Import only from `@trevonistrevon/pi-loop/api` — the package's `exports` map blocks deep `src/` imports.
-
-## Status line
-
-`pi-loop` keeps a compact persistent status line in the TUI.
-
-When active work exists, it shows a single focus-friendly line such as:
-
-```text
-1 loop · 1 monitor
-2 tasks | active: Fix deploy polling
-1 loop · 2 monitors · 3 tasks | next: Update README
-```
-
-When no loops, monitors, or native tasks are active, the status line clears completely.
-
-Only task counts and the single active/next task are shown there so attention stays on what is currently happening. Use `LoopList`, `MonitorList`, and `/tasks` for detail.
-
-## Configuration
-
-| Variable | Effect | Default |
-|---|---|---|
-| `PI_LOOP` | Store path override. `off` to disable, absolute or project-relative path | unset → derived from `PI_LOOP_SCOPE` |
-| `PI_LOOP_SCOPE` | `memory` (ephemeral), `session` (per-session file), `project` (shared) | `session` |
-| `PI_LOOP_DEBUG` | Debug logging to stderr | unset |
-
-In `session` scope (default), loop and task files are saved per session ID (e.g. `.pi/loops/loops-<sessionId>.json` and `.pi/tasks/tasks-<sessionId>.json`) so concurrent sessions and worktree agents do not share state. In `memory` scope nothing persists to disk.
-
-### Recommended scope policy
-
-Keep `PI_LOOP_SCOPE=session` as the default.
-
-- `session` is the best balance for normal use: it preserves loops/tasks across a session restart while isolating concurrent sessions and worktrees.
-- `memory` is best for disposable scratch work, tests, or situations where you explicitly do not want any persisted loop/task state.
-- `project` should be opt-in for intentionally shared automation, because it allows multiple sessions in the same repo to see the same persisted state.
-
-
-
-## Limits
+| `/loop` | Create or manage scheduled, event, and dynamic goal loops |
+| `/tasks` | Manage native fallback tasks when `pi-tasks` is absent |
+| `LoopCreate`, `LoopList`, `LoopUpdate`, `LoopDelete` | Create and control loops |
+| `MonitorCreate`, `MonitorList`, `MonitorStop` | Run and inspect background commands |
+| `TaskCreate`, `TaskList`, `TaskUpdate`, `TaskDelete` | Native fallback task management |
 
-25 active loops, 25 running monitors. Recurring loops expire after 7 days.
+See the [usage guide](./docs/USAGE_GUIDE.md) for trigger types, dynamic loop lifecycle, monitor behavior, task integration, configuration, events, and the public RPC API.
 
 ## Development
 

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;
@@ -17,6 +24,7 @@ export interface LoopCommandOptions {
     getStore: () => LoopStoreLike;
     getTriggerSystem: () => TriggerSystemLike;
     updateWidget: () => void;
+    onDynamicLoopActivated?: (entry: LoopEntry) => void;
 }
 export declare function registerLoopCommand(options: LoopCommandOptions): void;
 export {};

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;
+    const { pi, getStore, getTriggerSystem, updateWidget, onDynamicLoopActivated } = options;
+    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,18 @@ 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");
+        onDynamicLoopActivated?.(entry);
+    }
     async function viewLoops(ui) {
         const loops = getStore().list();
         if (loops.length === 0) {
@@ -41,12 +92,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,10 +122,14 @@ 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");
+                    if (resumed.trigger.type === "dynamic")
+                        onDynamicLoopActivated?.(resumed);
                 }
             }
         }
@@ -91,11 +141,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 +162,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 ──
@@ -306,6 +331,9 @@ export default function (pi) {
         updateWidget: () => {
             widget.update();
         },
+        onDynamicLoopActivated: (entry) => {
+            onLoopFire(entry);
+        },
     });
     // ── Native task tools (only when pi-tasks is absent) ──
     // Only tool/command registration stays deferred: the tool names collide with

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;