@trevonistrevon/pi-loop 0.5.9 → 0.6.1

package/CHANGELOG.md

@@ -1,5 +1,77 @@
 # 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)
+
+
+### ⚠ BREAKING CHANGES
+
+* package exports map blocks deep src/ imports — consumers must use @trevonistrevon/pi-loop/api. tasks:updated now reports previousStatus at edit time, not pre-transition.
+
+### Features
+
+* add maxFires for self-limiting loops, event-driven prompt steering ([52b50f0](https://github.com/trvon/pi-loop/commit/52b50f0d2b8c0b1df6aa74b09a8561807b549fe6))
+* add native task fallback and compact task tracker ([6b5b6ff](https://github.com/trvon/pi-loop/commit/6b5b6fff53cc7810242e4f9081fe6d21b318c654))
+* add task decomposition guidance to TaskCreate prompt ([4c51e72](https://github.com/trvon/pi-loop/commit/4c51e72a7317e1433cdb5bed6cfc9dfa521b5bfb))
+* add tasks:rpc:clean RPC for sweeping done tasks ([73812ed](https://github.com/trvon/pi-loop/commit/73812ed4c3efeb08e97908e6de6435f65c768440))
+* auto-create task worker loop at backlog threshold ([430663a](https://github.com/trvon/pi-loop/commit/430663a8042560688e08bd08129ea57b190ccecc))
+* canonical rpc module + init-time task server ([7335eff](https://github.com/trvon/pi-loop/commit/7335eff6440452178ae9db3cb22a49098ad3953d))
+* generalize task backlog loop cleanup ([9132948](https://github.com/trvon/pi-loop/commit/9132948dc9e22cda32adf6e8c5e13a7203f9c864))
+* goal prompt and loading refinements ([b31df23](https://github.com/trvon/pi-loop/commit/b31df23c240f0bde7fb69fb8ea702429576276c7))
+* prune completed tasks after successful git commit ([cba120b](https://github.com/trvon/pi-loop/commit/cba120be3a7fcdf71b7f7649b414577412d26a94))
+* refining monitor interface ([66a6007](https://github.com/trvon/pi-loop/commit/66a60077093f40c258efeeb971f6f8db74e24f83))
+* show worker-loop hint when pending tasks reach 5+ ([74dbf2c](https://github.com/trvon/pi-loop/commit/74dbf2cbf7f55a4206762eee3731798527537ab5))
+* skip loop fires when autoTask loop has no pending tasks ([f2feb07](https://github.com/trvon/pi-loop/commit/f2feb079d5b520ed4c4dd0dc85d5b385efc45c45))
+* **tasks:** add native rpc update and backlog signals ([31d06f6](https://github.com/trvon/pi-loop/commit/31d06f61fce1333c359f0d38def7406474144f8b))
+* **tasks:** emit native task events with previousStatus tracking ([61b49ea](https://github.com/trvon/pi-loop/commit/61b49ea5703597b02754998269edfdc5b2018ebb))
+
+
+### Bug Fixes
+
+* add trigger validation, readOnly flag, and edge-case tests ([91baa07](https://github.com/trvon/pi-loop/commit/91baa07884bc20d760c7a3642c3ec462997fc0d3))
+* auto-delete worker loop when task backlog clears ([502fa10](https://github.com/trvon/pi-loop/commit/502fa106b8862c06648e6be373e5980d2af18f6f))
+* auto-expire monitor:done loops, buffer output, show completed monitors ([a3ec5de](https://github.com/trvon/pi-loop/commit/a3ec5de5847d67bddee9c572079b559b03e35f3f))
+* deduplicate loop follow-up messages to prevent flood ([1613511](https://github.com/trvon/pi-loop/commit/1613511a2453d346edb59919beed2bdb18c05f63))
+* delete done loops/monitors immediately instead of marking expired ([43f5220](https://github.com/trvon/pi-loop/commit/43f5220a3e6d807234e4bdb7611e44c0fa7468ec))
+* delete event maxFires loops immediately ([12335e7](https://github.com/trvon/pi-loop/commit/12335e75dcf8d17a2c887966cae180d2b2f848da))
+* deliver monitor onDone wakes without event dependency ([79d6a8b](https://github.com/trvon/pi-loop/commit/79d6a8b925aa98e8de0ea1b12addd5e0d2db0c47))
+* derive jitter ceiling from cron step, delete expired event loops ([6d13935](https://github.com/trvon/pi-loop/commit/6d13935e79d2367072bec027d5ef2cb430eff44a))
+* flush buffered worker wakes on agent end ([7a7dedf](https://github.com/trvon/pi-loop/commit/7a7dedf3ec7f16eb63edbfaf93e5dae9ed7a8f25))
+* harden TaskUpdate prompt to prevent taskId alias errors ([5dfefd9](https://github.com/trvon/pi-loop/commit/5dfefd96bb08c29d192de472c6224ac434394b6f))
+* **injection:** use before_agent_start message, not tool_result ([99a6317](https://github.com/trvon/pi-loop/commit/99a6317aabde8ce9d4f9e0c3065f42b6c6111259))
+* loop trigger fix ([619f32c](https://github.com/trvon/pi-loop/commit/619f32c48134d9cc1376a89a62a7c8d729321143))
+* **monitor:** make MonitorManager spawn-injectable, fix CI test timeouts ([f277646](https://github.com/trvon/pi-loop/commit/f277646b95369b43508fbbc8cc7eef5e37580781))
+* **monitor:** prune stopped/timed-out monitors ([a46f6e8](https://github.com/trvon/pi-loop/commit/a46f6e8f2b99fa39bd11ff22d1a34999e1ac4434))
+* only dedup recurring loop fires, always deliver one-shot events ([352e50e](https://github.com/trvon/pi-loop/commit/352e50e1de14ecd8d884b18a8e72572270ca90e9))
+* **persist:** expire event loops on session start, clean stale monitors ([7f0876d](https://github.com/trvon/pi-loop/commit/7f0876d821e93e663f43ec2d5351bc9a37223b4b))
+* recommend 5m default interval in LoopCreate task-continuation prompt ([1af3bcd](https://github.com/trvon/pi-loop/commit/1af3bcd35a2782f9fc333559d293c665db76c234))
+* release please fix ([16e2304](https://github.com/trvon/pi-loop/commit/16e2304ea3112664c12c65b4e098e04d390f93f0))
+* **reminders:** make loop reminder directive, not informational ([e21174d](https://github.com/trvon/pi-loop/commit/e21174df3d1d9403684e094f5763db33ed9cb732))
+* repair native task fallback compilation ([a8cef04](https://github.com/trvon/pi-loop/commit/a8cef04eabd8a8af404d27ffa756266ee6a188ec))
+* **runtime:** unref retention timer, swallow heartbeat pump errors ([602816b](https://github.com/trvon/pi-loop/commit/602816b3abb06859a0268c02119cc753de03decb))
+* scope native task files by session, prevent cross-session leakage ([0436710](https://github.com/trvon/pi-loop/commit/04367102414dd56f7668e1522b91c6f089490979))
+* **tasks:** gate late native RPC probes ([c97f4ad](https://github.com/trvon/pi-loop/commit/c97f4ad6800c00b9858c1a8e640f13e699e0c26a))
+* **tasks:** guard native fallback registration ([7d3b74a](https://github.com/trvon/pi-loop/commit/7d3b74abfa637bbe370ae232b8067e7bc5205ea1))
+* **trigger:** auto-expire non-recurring event loops ([178f9fd](https://github.com/trvon/pi-loop/commit/178f9fd6a6548a04307f3ed83935068a235c24d3))
+* use pi.hasPendingMessages() instead of bespoke tracking Set ([dab60d4](https://github.com/trvon/pi-loop/commit/dab60d46340fab04ae74b80044ad03b6b0ca9fe8))
+
+
+### Performance Improvements
+
+* **test:** replace real 6.1s waits with fake-timer advance in onDone tests ([c713ad3](https://github.com/trvon/pi-loop/commit/c713ad36f958d53e75c4c7d7fd723c06ee420543))
+
 ## [0.1.2]
 
 - Added `onDone` parameter to `MonitorCreate` — auto-creates a completion loop so the agent is notified when a background process finishes, no polling needed

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
 
@@ -81,9 +93,56 @@ If `pi-tasks` does not respond during startup detection, `pi-loop` registers a n
 - `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.

package/dist/api.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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";

package/dist/api.js

@@ -0,0 +1,10 @@
+/**
+ * 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 { replyChannel, SUBAGENTS_RPC, TASK_EVENTS, TASKS_RPC, } from "./rpc/channels.js";
+export { handleRpc, PROTOCOL_VERSION, RpcError, 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";

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,19 +91,14 @@ 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);
         if (!selected || selected === "< Back")
             return;
         const match = selected.match(/#(\d+)/);
-        if (match) {
+        if (match?.[1]) {
             const entry = getStore().get(match[1]);
             if (entry) {
                 const actions = ["x Delete"];
@@ -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];
-                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/commands/tasks-command.js

@@ -47,10 +47,10 @@ export function registerTasksCommand(options) {
             await createNativeTaskInteractively(ui);
             return viewNativeTasks(ui);
         }
-        const match = selected.match(/#(\d+)/);
-        if (!match)
+        const taskId = selected.match(/#(\d+)/)?.[1];
+        if (!taskId)
             return viewNativeTasks(ui);
-        const task = taskStore.get(match[1]);
+        const task = taskStore.get(taskId);
         if (!task)
             return viewNativeTasks(ui);
         const actions = ["x Delete"];

package/dist/coordinator.d.ts

@@ -1,5 +1,5 @@
 export type ReducerSource = "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
-export type ReducerEntityType = "task" | "loop" | "monitor" | "notification" | "goal";
+export type ReducerEntityType = "task" | "loop" | "monitor" | "notification";
 export interface ReducerEvent<TType extends string = string, TPayload = unknown> {
     type: TType;
     at: number;

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";