@trevonistrevon/pi-loop 0.1.0

package/dist/index.js

@@ -0,0 +1,614 @@
+/**
+ * @trevonistrevon/pi-loop — A pi extension providing cron/event-based agent re-wake loops and background process monitoring.
+ *
+ * Tools:
+ *   LoopCreate    — Create a scheduled or event-triggered re-wake loop
+ *   LoopList      — List all active loops with status and next-fire times
+ *   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 a re-wake loop: /loop [interval] [prompt]
+ *   /loops   — Interactive menu: view, create, cancel, settings
+ */
+import { randomUUID } from "node:crypto";
+import { join, resolve } from "node:path";
+import { Type } from "typebox";
+import { parseInterval } from "./loop-parse.js";
+import { MonitorManager } from "./monitor-manager.js";
+import { CronScheduler } from "./scheduler.js";
+import { LoopStore } from "./store.js";
+import { TriggerSystem } from "./trigger-system.js";
+import { LoopWidget } from "./ui/widget.js";
+const DEBUG = !!process.env.PI_LOOP_DEBUG;
+function debug(...args) {
+    if (DEBUG)
+        console.error("[pi-loop]", ...args);
+}
+function textResult(msg) {
+    return { content: [{ type: "text", text: msg }], details: undefined };
+}
+const LOOP_TOOL_NAMES = new Set(["LoopCreate", "LoopList", "LoopDelete", "MonitorCreate", "MonitorList", "MonitorStop"]);
+const REMINDER_INTERVAL = 3;
+const SYSTEM_REMINDER_TEMPLATE = `<system-reminder>
+Scheduled loop "%propmpt%" fired. Trigger: %trigger_info%.
+[loop:%loop_id%]
+</system-reminder>`;
+export default function (pi) {
+    const piLoopEnv = process.env.PI_LOOP;
+    const piLoopScope = process.env.PI_LOOP_SCOPE;
+    let loopScope = piLoopScope ?? "session";
+    function resolveStorePath(sessionId) {
+        if (piLoopEnv === "off")
+            return undefined;
+        if (piLoopEnv?.startsWith("/"))
+            return piLoopEnv;
+        if (piLoopEnv?.startsWith("."))
+            return resolve(piLoopEnv);
+        if (piLoopEnv)
+            return piLoopEnv;
+        if (loopScope === "memory")
+            return undefined;
+        if (loopScope === "session" && sessionId) {
+            return join(process.cwd(), ".pi", "loops", `loops-${sessionId}.json`);
+        }
+        if (loopScope === "session")
+            return undefined;
+        return join(process.cwd(), ".pi", "loops", "loops.json");
+    }
+    let store = new LoopStore(resolveStorePath());
+    const monitorManager = new MonitorManager(pi);
+    let scheduler;
+    let triggerSystem;
+    const widget = new LoopWidget(store, undefined, monitorManager);
+    scheduler = new CronScheduler(store, onLoopFire);
+    widget.setScheduler(scheduler);
+    triggerSystem = new TriggerSystem(pi, scheduler);
+    // ── pi-tasks integration ──
+    let tasksAvailable = false;
+    const _PROTOCOL_VERSION = 1;
+    function checkTasksVersion() {
+        const requestId = randomUUID();
+        const timer = setTimeout(() => { unsub(); }, 5000);
+        const unsub = pi.events.on(`tasks:rpc:ping:reply:${requestId}`, (raw) => {
+            unsub();
+            clearTimeout(timer);
+            const remoteVersion = raw?.data?.version;
+            if (remoteVersion !== undefined)
+                tasksAvailable = true;
+        });
+        pi.events.emit("tasks:rpc:ping", { requestId });
+    }
+    checkTasksVersion();
+    pi.events.on("tasks:ready", () => checkTasksVersion());
+    async function autoCreateTask(entry) {
+        if (!tasksAvailable || !entry.autoTask)
+            return undefined;
+        try {
+            const requestId = randomUUID();
+            const taskId = await new Promise((resolve, _reject) => {
+                const timer = setTimeout(() => { unsub(); resolve(undefined); }, 5000);
+                const unsub = pi.events.on(`tasks:rpc:create:reply:${requestId}`, (raw) => {
+                    unsub();
+                    clearTimeout(timer);
+                    const reply = raw;
+                    if (reply.success && reply.data)
+                        resolve(reply.data.id);
+                    else
+                        resolve(undefined);
+                });
+                pi.events.emit("tasks:rpc:create", {
+                    requestId,
+                    subject: entry.prompt.slice(0, 80),
+                    description: `Auto-created from loop #${entry.id}`,
+                    metadata: { loopId: entry.id, trigger: entry.trigger },
+                });
+            });
+            return taskId;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    // ── Loop fire handler ──
+    function onLoopFire(entry) {
+        debug(`loop:fire #${entry.id}`, { prompt: entry.prompt.slice(0, 50) });
+        if (entry.autoTask) {
+            autoCreateTask(entry).then((taskId) => {
+                if (taskId)
+                    debug(`loop #${entry.id} → task #${taskId}`);
+            });
+        }
+        pi.events.emit("loop:fire", {
+            loopId: entry.id,
+            prompt: entry.prompt,
+            trigger: entry.trigger,
+            timestamp: Date.now(),
+        });
+    }
+    // ── Session lifecycle ──
+    let storeUpgraded = false;
+    let persistedShown = false;
+    let _latestCtx;
+    function upgradeStoreIfNeeded(ctx) {
+        if (storeUpgraded)
+            return;
+        if (loopScope === "session" && !piLoopEnv) {
+            const sessionId = ctx.sessionManager.getSessionId();
+            const path = resolveStorePath(sessionId);
+            store = new LoopStore(path);
+            widget.setStore(store);
+            scheduler = new CronScheduler(store, onLoopFire);
+            widget.setScheduler(scheduler);
+            triggerSystem = new TriggerSystem(pi, scheduler);
+        }
+        storeUpgraded = true;
+    }
+    function showPersistedLoops(_isResume = false) {
+        if (persistedShown)
+            return;
+        persistedShown = true;
+        const loops = store.list();
+        if (loops.length > 0) {
+            store.clearExpired();
+            triggerSystem.start();
+            widget.update();
+        }
+    }
+    pi.on("turn_start", async (_event, ctx) => {
+        _latestCtx = ctx;
+        widget.setUICtx(ctx.ui);
+        upgradeStoreIfNeeded(ctx);
+    });
+    pi.on("before_agent_start", async (_event, ctx) => {
+        _latestCtx = ctx;
+        widget.setUICtx(ctx.ui);
+        upgradeStoreIfNeeded(ctx);
+        showPersistedLoops();
+    });
+    pi.on("session_switch", async (event, ctx) => {
+        _latestCtx = ctx;
+        widget.setUICtx(ctx.ui);
+        triggerSystem.stop();
+        const isResume = event?.reason === "resume";
+        storeUpgraded = false;
+        persistedShown = false;
+        if (!isResume && loopScope === "memory") {
+            store.clearAll();
+        }
+        upgradeStoreIfNeeded(ctx);
+        showPersistedLoops(isResume);
+    });
+    // ── System-reminder injection for loop fires ──
+    let currentTurn = 0;
+    let lastLoopToolUseTurn = 0;
+    let reminderInjectedThisCycle = false;
+    const pendingReminders = [];
+    pi.on("loop:fire", (data) => {
+        const triggerInfo = typeof data.trigger === "string"
+            ? data.trigger
+            : data.trigger?.type === "cron"
+                ? `schedule: ${data.trigger.schedule}`
+                : data.trigger?.type === "event"
+                    ? `event: ${data.trigger.source}`
+                    : `hybrid`;
+        const reminder = SYSTEM_REMINDER_TEMPLATE
+            .replace("%prompt%", data.prompt || "loop fired")
+            .replace("%trigger_info%", triggerInfo)
+            .replace("%loop_id%", data.loopId || "unknown");
+        pendingReminders.push(reminder);
+    });
+    pi.on("turn_start", async () => {
+        currentTurn++;
+    });
+    pi.on("tool_result", async (event) => {
+        if (LOOP_TOOL_NAMES.has(event.toolName)) {
+            lastLoopToolUseTurn = currentTurn;
+            reminderInjectedThisCycle = false;
+            return {};
+        }
+        if (currentTurn - lastLoopToolUseTurn < REMINDER_INTERVAL || reminderInjectedThisCycle) {
+            return {};
+        }
+        if (pendingReminders.length === 0)
+            return {};
+        reminderInjectedThisCycle = true;
+        lastLoopToolUseTurn = currentTurn;
+        const reminder = pendingReminders.shift();
+        return {
+            content: [...event.content, { type: "text", text: reminder }],
+        };
+    });
+    // ──────────────────────────────────────────────────
+    // Tool 1: LoopCreate
+    // ──────────────────────────────────────────────────
+    pi.registerTool({
+        name: "LoopCreate",
+        label: "LoopCreate",
+        description: `Create a scheduled repeating task (loop) that runs a prompt on a timer or when an event fires.
+
+Use this tool whenever the user asks to:
+- "create a loop" to check something periodically
+- "run every X seconds/minutes/hours"
+- "remind me to check..."
+- "watch for..." or "when X happens, do Y"
+- "schedule a recurring check"
+- set up a periodic monitor or poller
+
+DO NOT use raw Bash loops (for/sleep/while). Use LoopCreate instead — it integrates with the session lifecycle, survives across turns, and the scheduler handles timing.
+
+## When NOT to Use
+
+Skip this tool when the task is a one-off check (just do it directly) or when the user wants a purely reactive hook.
+
+## Trigger Types
+
+- **cron**: time-based. "30s" (rounded to 1m), "5m", "2h", "1d", or full cron like "0 9 * * 1-5"
+- **event**: fires on pi events like "tool_execution_start", "before_agent_start"
+- **hybrid**: both cron + event with debounce
+
+## Parameters
+
+- **trigger**: interval like "30s", "5m", "2h", event source, or hybrid spec
+- **prompt**: what to do when the loop fires (e.g., "check if the build passed")
+- **recurring**: repeat or fire once (default: true)
+- **autoTask**: if pi-tasks is loaded, auto-create a task on each fire
+- **triggerType**: "cron", "event", or "hybrid" (inferred if omitted)`,
+        promptGuidelines: [
+            "When the user asks for a loop, repeating task, periodic check, or scheduled reminder, use LoopCreate — not raw Bash for/sleep/while.",
+            "Use LoopCreate for any 'every X seconds/minutes/hours' requests.",
+            "After creating a loop, tell the user the loop ID so they can cancel it with LoopDelete.",
+        ],
+        parameters: Type.Object({
+            trigger: Type.String({ description: "Cron expression (e.g., '5m', '1h', '0 9 * * 1-5'), event source (e.g., 'tool_execution_start'), or JSON hybrid spec" }),
+            prompt: Type.String({ description: "Prompt to run when the loop fires" }),
+            recurring: Type.Optional(Type.Boolean({ description: "Whether loop repeats (default: true)", default: true })),
+            autoTask: Type.Optional(Type.Boolean({ description: "Auto-create pi-tasks task on fire", default: false })),
+            triggerType: Type.Optional(Type.String({ description: "cron, event, or hybrid (inferred from trigger string if omitted)", enum: ["cron", "event", "hybrid"] })),
+            debounceMs: Type.Optional(Type.Number({ description: "Debounce for hybrid triggers (default: 30000)", default: 30000 })),
+        }),
+        execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            const { trigger: triggerInput, prompt, recurring, autoTask, triggerType, debounceMs } = params;
+            let trigger;
+            const inferred = triggerType ?? inferTriggerType(triggerInput);
+            if (inferred === "cron") {
+                const parsed = parseInterval(triggerInput);
+                trigger = { type: "cron", schedule: parsed.cron };
+            }
+            else if (inferred === "event") {
+                trigger = { type: "event", source: triggerInput };
+            }
+            else {
+                const cronPart = triggerInput.match(/cron:?\s*(\S+)/)?.[1] || triggerInput;
+                const eventPart = triggerInput.match(/event:?\s*(\S+)/)?.[1];
+                const parsed = parseInterval(cronPart);
+                trigger = {
+                    type: "hybrid",
+                    cron: parsed.cron,
+                    event: { source: eventPart || "tool_execution_start" },
+                    debounceMs: debounceMs ?? 30000,
+                };
+            }
+            const entry = store.create(trigger, prompt, {
+                recurring: recurring ?? (inferred !== "event"),
+                autoTask,
+                selfPaced: triggerInput === "self-paced" || prompt.toLowerCase().includes("self-paced"),
+            });
+            triggerSystem.add(entry);
+            widget.update();
+            const triggerDesc = trigger.type === "cron"
+                ? `schedule: ${trigger.schedule}`
+                : trigger.type === "event"
+                    ? `event: ${trigger.source}`
+                    : `hybrid: cron ${trigger.cron} + event ${trigger.event.source}`;
+            return Promise.resolve(textResult(`Loop #${entry.id} created: ${entry.prompt.slice(0, 60)}\n` +
+                `Trigger: ${triggerDesc}\n` +
+                `Recurring: ${entry.recurring}\n` +
+                (entry.autoTask ? `Auto-task: enabled\n` : "") +
+                (tasksAvailable ? "" : "(pi-tasks not detected — autoTask will have no effect)\n") +
+                `ID: ${entry.id} (use LoopDelete to cancel)`));
+        },
+    });
+    function inferTriggerType(input) {
+        if (input.includes("hybrid") || (input.includes("cron") && input.includes("event")))
+            return "hybrid";
+        if (/^\d+\s*[smhd]$/i.test(input.trim()))
+            return "cron";
+        if (/^(\*|\d+)/.test(input.trim()) && input.trim().split(/\s+/).length === 5)
+            return "cron";
+        return "event";
+    }
+    // ──────────────────────────────────────────────────
+    // Tool 2: LoopList
+    // ──────────────────────────────────────────────────
+    pi.registerTool({
+        name: "LoopList",
+        label: "LoopList",
+        description: `List all active scheduled loops with their IDs, triggers, and next-fire times.
+
+Use this before creating new loops to avoid duplicates, or to find IDs for LoopDelete.`,
+        parameters: Type.Object({}),
+        execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
+            const loops = store.list();
+            if (loops.length === 0)
+                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"
+                    ? scheduler.nextFire(entry.id)
+                    : undefined;
+                const statusIcon = entry.status === "active" ? "⟳" : entry.status === "paused" ? "⏸" : "✗";
+                let line = `${statusIcon} #${entry.id} [${entry.status}] ${entry.prompt.slice(0, 60)}`;
+                line += ` (${triggerDesc})`;
+                if (nextFire) {
+                    const remaining = Math.max(0, nextFire - Date.now());
+                    line += ` next: ${formatRemaining(remaining)}`;
+                }
+                if (entry.autoTask)
+                    line += " [auto-task]";
+                lines.push(line);
+            }
+            return Promise.resolve(textResult(lines.join("\n")));
+        },
+    });
+    function formatRemaining(ms) {
+        if (ms < 60000)
+            return `${Math.round(ms / 1000)}s`;
+        if (ms < 3600000)
+            return `${Math.round(ms / 60000)}m`;
+        return `${Math.round(ms / 3600000)}h`;
+    }
+    // ──────────────────────────────────────────────────
+    // Tool 3: LoopDelete
+    // ──────────────────────────────────────────────────
+    pi.registerTool({
+        name: "LoopDelete",
+        label: "LoopDelete",
+        description: `Delete or pause a loop by its ID.
+
+Use "pause" to temporarily stop a loop without removing it. Use "delete" to permanently remove it.`,
+        parameters: Type.Object({
+            id: Type.String({ description: "Loop ID to delete or pause" }),
+            action: Type.Optional(Type.String({ description: "delete or pause (default: delete)", enum: ["delete", "pause"], default: "delete" })),
+        }),
+        execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            const { id, action } = params;
+            if (action === "pause") {
+                const result = store.update(id, { status: "paused" });
+                if (!result.entry)
+                    return Promise.resolve(textResult(`Loop #${id} not found`));
+                triggerSystem.remove(id);
+                widget.update();
+                return Promise.resolve(textResult(`Loop #${id} paused`));
+            }
+            triggerSystem.remove(id);
+            const deleted = store.delete(id);
+            widget.update();
+            if (deleted)
+                return Promise.resolve(textResult(`Loop #${id} deleted`));
+            return Promise.resolve(textResult(`Loop #${id} not found`));
+        },
+    });
+    // ──────────────────────────────────────────────────
+    // Tool 4: MonitorCreate
+    // ──────────────────────────────────────────────────
+    pi.registerTool({
+        name: "MonitorCreate",
+        label: "MonitorCreate",
+        description: `Start a background command and stream its output via pi events.
+
+The monitor runs a shell command in the background. Each output line is emitted as a "monitor:output" pi event. Use this to watch logs, tail files, poll APIs, etc.
+
+Events emitted:
+- "monitor:output" — { monitorId, line, timestamp } for each output line
+- "monitor:done" — { monitorId, exitCode } on clean exit
+- "monitor:error" — { monitorId, error } on failure`,
+        parameters: Type.Object({
+            command: Type.String({ description: "Shell command to run in background" }),
+            description: Type.Optional(Type.String({ description: "Human-readable description" })),
+            timeout: Type.Optional(Type.Number({ description: "Auto-stop after N ms (default: 300000, 0 = no timeout)", default: 300000 })),
+        }),
+        execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            if (monitorManager.list().filter(m => m.status === "running").length >= 25) {
+                return Promise.resolve(textResult("Maximum of 25 running monitors reached. Stop some before creating new ones."));
+            }
+            const entry = monitorManager.create(params.command, params.description, params.timeout);
+            widget.update();
+            return Promise.resolve(textResult(`Monitor #${entry.id} started: ${entry.command.slice(0, 60)}\n` +
+                `Output stream: monitor:output (monitorId: ${entry.id})\n` +
+                `Timeout: ${params.timeout ? `${params.timeout / 1000}s` : "none"}`));
+        },
+    });
+    // ──────────────────────────────────────────────────
+    // Tool 5: MonitorList
+    // ──────────────────────────────────────────────────
+    pi.registerTool({
+        name: "MonitorList",
+        label: "MonitorList",
+        description: `List all monitors with their status, command, and output line count.`,
+        parameters: Type.Object({}),
+        execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
+            const monitors = monitorManager.list();
+            if (monitors.length === 0)
+                return Promise.resolve(textResult("No monitors running."));
+            const lines = [];
+            for (const m of monitors) {
+                const icon = m.status === "running" ? "◉" : m.status === "completed" ? "✓" : "✗";
+                const age = Date.now() - m.startedAt;
+                const ageStr = formatRemaining(age);
+                lines.push(`${icon} #${m.id} [${m.status}] ${m.command.slice(0, 50)} — ${m.outputLines} lines (${ageStr})`);
+            }
+            return Promise.resolve(textResult(lines.join("\n")));
+        },
+    });
+    // ──────────────────────────────────────────────────
+    // Tool 6: MonitorStop
+    // ──────────────────────────────────────────────────
+    pi.registerTool({
+        name: "MonitorStop",
+        label: "MonitorStop",
+        description: `Stop a running monitor. Sends SIGTERM, waits 5s, then SIGKILL.
+
+Use MonitorList to find the monitor ID, then stop it with this tool.`,
+        parameters: Type.Object({
+            monitorId: Type.String({ description: "Monitor ID to stop" }),
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            const stopped = await monitorManager.stop(params.monitorId);
+            widget.update();
+            if (stopped)
+                return textResult(`Monitor #${params.monitorId} stopped`);
+            return textResult(`Monitor #${params.monitorId} not found or not running`);
+        },
+    });
+    // ──────────────────────────────────────────────────
+    // /loop command
+    // ──────────────────────────────────────────────────
+    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",
+        handler: async (args, ctx) => {
+            const trimmed = args.trim();
+            const ui = ctx.ui;
+            if (!trimmed) {
+                const choice = await ui.select("Loop", [
+                    "Create scheduled loop",
+                    "Create event-triggered loop",
+                    "View active loops",
+                    "Settings",
+                ]);
+                if (!choice)
+                    return;
+                if (choice.startsWith("Create scheduled"))
+                    return scheduleLoop(ui);
+                if (choice.startsWith("Create event"))
+                    return eventLoop(ui);
+                if (choice.startsWith("View active"))
+                    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 = store.create(trigger, prompt, { recurring: true });
+                    triggerSystem.add(entry);
+                    widget.update();
+                    ui.notify(`Loop #${entry.id} created: every ${parsed.description} — ${prompt.slice(0, 50)}`, "info");
+                }
+                catch (err) {
+                    ui.notify(err.message, "error");
+                }
+                return;
+            }
+            const choice = await ui.select("Loop mode", [
+                `Scheduled: "${trimmed.slice(0, 50)}"`,
+                `Event-triggered: "${trimmed.slice(0, 50)}"`,
+                `Self-paced: "${trimmed.slice(0, 50)}"`,
+            ]);
+            if (!choice)
+                return;
+            if (choice.startsWith("Event"))
+                return eventLoop(ui, trimmed);
+            return scheduleLoop(ui, trimmed);
+        },
+    });
+    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;
+        try {
+            const parsed = parseInterval(interval);
+            const trigger = { type: "cron", schedule: parsed.cron };
+            const entry = store.create(trigger, p, { recurring: true });
+            triggerSystem.add(entry);
+            widget.update();
+            ui.notify(`Loop #${entry.id} created: every ${parsed.description}`, "info");
+        }
+        catch (err) {
+            ui.notify(err.message, "error");
+        }
+    }
+    async function eventLoop(ui, prompt) {
+        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)");
+        if (!source)
+            return;
+        const trigger = { type: "event", source };
+        const entry = store.create(trigger, p, { recurring: true });
+        triggerSystem.add(entry);
+        widget.update();
+        ui.notify(`Event loop #${entry.id} created: fires on "${source}"`, "info");
+    }
+    async function viewLoops(ui) {
+        const loops = store.list();
+        if (loops.length === 0) {
+            await ui.select("No active loops", ["← Back"]);
+            return;
+        }
+        const choices = loops.map((l) => {
+            const icon = l.status === "active" ? "⟳" : l.status === "paused" ? "⏸" : "✗";
+            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})`;
+        });
+        choices.push("← Back");
+        const selected = await ui.select("Active Loops", choices);
+        if (!selected || selected === "← Back")
+            return;
+        const match = selected.match(/#(\d+)/);
+        if (match) {
+            const entry = store.get(match[1]);
+            if (entry) {
+                const actions = ["✗ Delete"];
+                if (entry.status === "active")
+                    actions.unshift("⏸ Pause");
+                else if (entry.status === "paused")
+                    actions.unshift("▶ Resume");
+                actions.push("← Back");
+                const action = await ui.select(`#${entry.id}: ${entry.prompt}\nTrigger: ${JSON.stringify(entry.trigger)}`, actions);
+                if (action === "✗ Delete") {
+                    triggerSystem.remove(entry.id);
+                    store.delete(entry.id);
+                    widget.update();
+                    ui.notify(`Loop #${entry.id} deleted`, "info");
+                }
+                else if (action === "⏸ Pause") {
+                    store.update(entry.id, { status: "paused" });
+                    triggerSystem.remove(entry.id);
+                    widget.update();
+                    ui.notify(`Loop #${entry.id} paused`, "info");
+                }
+                else if (action === "▶ Resume") {
+                    store.update(entry.id, { status: "active" });
+                    triggerSystem.add(entry);
+                    widget.update();
+                    ui.notify(`Loop #${entry.id} resumed`, "info");
+                }
+            }
+        }
+        return viewLoops(ui);
+    }
+    async function settings(ui) {
+        const loops = store.list();
+        const active = loops.filter(l => l.status === "active").length;
+        ui.notify(`${active}/${loops.length} active loops (max 25)`, "info");
+    }
+}

package/dist/loop-parse.d.ts

@@ -0,0 +1,6 @@
+export declare function parseInterval(input: string): {
+    cron: string;
+    description: string;
+};
+export declare function cronToNextFire(cronExpr: string, fromDate?: Date): Date;
+export declare function computeJitter(taskId: string, recurring: boolean, scheduleMinutes: number): number;