@trevonistrevon/pi-loop 0.4.11 → 0.5.1

package/README.md

@@ -77,37 +77,48 @@ Works with [@tintinweb/pi-tasks](https://github.com/tintinweb/pi-tasks). Pass `a
 
 If `pi-tasks` does not respond during startup detection, `pi-loop` registers a native fallback task system for the session:
 
-- persistent store at `.pi/tasks/tasks.json`
+- session- or project-scoped task files under `.pi/tasks/` depending on `PI_LOOP_SCOPE`
 - `TaskCreate`, `TaskList`, `TaskUpdate`, `TaskDelete`
 - `/tasks` interactive viewer
-- compact widget task tracking
+- compact status-line task tracking
 
 This fallback is session-sticky: `pi-loop` decides once at startup whether `pi-tasks` or native tasks own task management for that session.
 
-## Widget
+## Status line
 
-`pi-loop` keeps a compact persistent TUI widget above the editor.
+`pi-loop` keeps a compact persistent status line in the TUI.
 
-It now shows a single focus-friendly status line such as:
+When active work exists, it shows a single focus-friendly line such as:
 
 ```text
-none
 1 loop · 1 monitor
 2 tasks | active: Fix deploy polling
 1 loop · 2 monitors · 3 tasks | next: Update README
 ```
 
-Only task counts and the single active/next task are shown in the widget so attention stays on what is currently happening. Use `LoopList`, `MonitorList`, and `/tasks` for detail.
+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. `off` to disable, absolute or project-relative path | `.pi/loops/loops.json` |
+| `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/tasks/tasks-<sessionId>.json`) so concurrent sessions and worktree agents do not share state. In `memory` scope nothing persists to disk.
+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
 

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

@@ -0,0 +1,22 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { LoopEntry, Trigger } from "../types.js";
+interface LoopStoreLike {
+    list(): LoopEntry[];
+    get(id: string): LoopEntry | undefined;
+    create(trigger: Trigger, prompt: string, options?: Partial<LoopEntry>): LoopEntry;
+    pause(id: string): LoopEntry | undefined;
+    resume(id: string): LoopEntry | undefined;
+    delete(id: string): boolean;
+}
+interface TriggerSystemLike {
+    add(entry: LoopEntry): void;
+    remove(id: string): void;
+}
+export interface LoopCommandOptions {
+    pi: ExtensionAPI;
+    getStore: () => LoopStoreLike;
+    getTriggerSystem: () => TriggerSystemLike;
+    updateWidget: () => void;
+}
+export declare function registerLoopCommand(options: LoopCommandOptions): void;
+export {};

package/dist/commands/loop-command.js

@@ -0,0 +1,148 @@
+import { parseInterval } from "../loop-parse.js";
+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;
+        try {
+            const parsed = parseInterval(interval);
+            const trigger = { type: "cron", schedule: parsed.cron };
+            const entry = getStore().create(trigger, p, { recurring: true });
+            getTriggerSystem().add(entry);
+            updateWidget();
+            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 = getStore().create(trigger, p, { recurring: true });
+        getTriggerSystem().add(entry);
+        updateWidget();
+        ui.notify(`Event loop #${entry.id} created: fires on "${source}"`, "info");
+    }
+    async function viewLoops(ui) {
+        const loops = getStore().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" ? "-" : "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})`;
+        });
+        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 = getStore().get(match[1]);
+            if (entry) {
+                const actions = ["x 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 === "x Delete") {
+                    getTriggerSystem().remove(entry.id);
+                    getStore().delete(entry.id);
+                    updateWidget();
+                    ui.notify(`Loop #${entry.id} deleted`, "info");
+                }
+                else if (action === "- Pause") {
+                    getStore().pause(entry.id);
+                    getTriggerSystem().remove(entry.id);
+                    updateWidget();
+                    ui.notify(`Loop #${entry.id} paused`, "info");
+                }
+                else if (action === "* Resume") {
+                    getStore().resume(entry.id);
+                    getTriggerSystem().add(entry);
+                    updateWidget();
+                    ui.notify(`Loop #${entry.id} resumed`, "info");
+                }
+            }
+        }
+        return viewLoops(ui);
+    }
+    async function settings(ui) {
+        const loops = getStore().list();
+        const active = loops.filter((l) => l.status === "active").length;
+        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",
+        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 = 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");
+                }
+                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);
+        },
+    });
+}

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

@@ -0,0 +1,15 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { TaskStore } from "../task-store.js";
+export interface TaskBacklogResult {
+    created: boolean;
+    entry?: {
+        id: string;
+    };
+}
+export interface TasksCommandOptions {
+    pi: ExtensionAPI;
+    getNativeTaskStore: () => TaskStore | undefined;
+    evaluateTaskBacklog: (taskStore: TaskStore, pendingCount: number) => Promise<TaskBacklogResult>;
+    updateWidget: () => void;
+}
+export declare function registerTasksCommand(options: TasksCommandOptions): void;

package/dist/commands/tasks-command.js

@@ -0,0 +1,117 @@
+export function registerTasksCommand(options) {
+    const { pi, getNativeTaskStore, evaluateTaskBacklog, updateWidget } = options;
+    async function emitCreated(entry) {
+        pi.events.emit("tasks:created", {
+            taskId: entry.id,
+            subject: entry.subject,
+            description: entry.description,
+            status: entry.status,
+        });
+        const taskStore = getNativeTaskStore();
+        if (!taskStore)
+            return { created: false };
+        const backlog = await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
+        updateWidget();
+        return backlog;
+    }
+    async function createNativeTaskInteractively(ui) {
+        const taskStore = getNativeTaskStore();
+        if (!taskStore) {
+            ui.notify("Native tasks are unavailable while pi-tasks is active", "warning");
+            return;
+        }
+        const subject = await ui.input("Task subject");
+        if (!subject)
+            return;
+        const description = await ui.input("Task description") || subject;
+        const entry = taskStore.create(subject, description);
+        const backlog = await emitCreated(entry);
+        ui.notify(`Task #${entry.id} created`, "info");
+        if (backlog.created && backlog.entry) {
+            ui.notify(`Worker loop #${backlog.entry.id} auto-created`, "info");
+        }
+    }
+    async function viewNativeTasks(ui) {
+        const taskStore = getNativeTaskStore();
+        if (!taskStore) {
+            ui.notify("Native tasks are unavailable while pi-tasks is active", "warning");
+            return;
+        }
+        const tasks = taskStore.list();
+        const choices = tasks.map((task) => {
+            const icon = task.status === "in_progress" ? ">" : task.status === "completed" ? "ok" : "*";
+            return `${icon} #${task.id} [${task.status}] ${task.subject.slice(0, 60)}`;
+        });
+        choices.unshift("+ Create task");
+        choices.push("< Back");
+        const selected = await ui.select("Native Tasks", choices);
+        if (!selected || selected === "< Back")
+            return;
+        if (selected === "+ Create task") {
+            await createNativeTaskInteractively(ui);
+            return viewNativeTasks(ui);
+        }
+        const match = selected.match(/#(\d+)/);
+        if (!match)
+            return viewNativeTasks(ui);
+        const task = taskStore.get(match[1]);
+        if (!task)
+            return viewNativeTasks(ui);
+        const actions = ["x Delete"];
+        if (task.status === "pending") {
+            actions.unshift("ok Complete");
+            actions.unshift("> Start");
+        }
+        else if (task.status === "in_progress") {
+            actions.unshift("ok Complete");
+            actions.unshift("* Return to pending");
+        }
+        else {
+            actions.unshift("* Reopen");
+        }
+        actions.push("< Back");
+        const action = await ui.select(`#${task.id}: ${task.subject}\n\n${task.description}`, actions);
+        if (!action || action === "< Back")
+            return viewNativeTasks(ui);
+        if (action === "x Delete") {
+            taskStore.delete(task.id);
+            ui.notify(`Task #${task.id} deleted`, "info");
+        }
+        else if (action === "> Start") {
+            taskStore.start(task.id);
+            ui.notify(`Task #${task.id} started`, "info");
+        }
+        else if (action === "ok Complete") {
+            taskStore.complete(task.id);
+            ui.notify(`Task #${task.id} completed`, "info");
+        }
+        else if (action === "* Return to pending" || action === "* Reopen") {
+            taskStore.reopen(task.id);
+            ui.notify(`Task #${task.id} reopened`, "info");
+        }
+        updateWidget();
+        await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
+        return viewNativeTasks(ui);
+    }
+    pi.registerCommand("tasks", {
+        description: "View or manage native pi-loop tasks when pi-tasks is not installed",
+        handler: async (args, ctx) => {
+            const trimmed = args.trim();
+            const taskStore = getNativeTaskStore();
+            if (!taskStore) {
+                ctx.ui.notify("Native tasks are unavailable while pi-tasks is active", "warning");
+                return;
+            }
+            if (trimmed) {
+                const entry = taskStore.create(trimmed.slice(0, 80), trimmed);
+                const backlog = await emitCreated(entry);
+                ctx.ui.notify(`Task #${entry.id} created`, "info");
+                if (backlog.created && backlog.entry) {
+                    ctx.ui.notify(`Worker loop #${backlog.entry.id} auto-created`, "info");
+                }
+                return;
+            }
+            await viewNativeTasks(ctx.ui);
+        },
+    });
+}

package/dist/coordinator.d.ts

@@ -0,0 +1,35 @@
+export type ReducerSource = "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+export type ReducerEntityType = "task" | "loop" | "monitor" | "notification" | "goal";
+export interface ReducerEvent<TType extends string = string, TPayload = unknown> {
+    type: TType;
+    at: number;
+    source: ReducerSource;
+    entityType?: ReducerEntityType;
+    entityId?: string;
+    payload: TPayload;
+}
+export interface ReducerEffect<TEffect extends string = string, TPayload = unknown> {
+    type: TEffect;
+    entityType?: ReducerEntityType;
+    entityId?: string;
+    payload: TPayload;
+}
+export type DispatchEventEffect = ReducerEffect<"DISPATCH_EVENT", {
+    event: ReducerEvent;
+}>;
+export type AnyReducerEffect = ReducerEffect | DispatchEventEffect;
+export type ReducerHandler = (event: ReducerEvent) => undefined | AnyReducerEffect[] | Promise<undefined | AnyReducerEffect[]>;
+export type EffectHandler = (effect: ReducerEffect) => void | Promise<void>;
+export interface CoordinatorOptions {
+    reducers: ReducerHandler[];
+    effectHandlers?: Partial<Record<string, EffectHandler>>;
+    effectExecutor?: EffectHandler;
+    maxDispatchDepth?: number;
+}
+export declare class CoordinatorError extends Error {
+    constructor(message: string);
+}
+export interface Coordinator {
+    dispatch(event: ReducerEvent): Promise<void>;
+}
+export declare function createCoordinator(options: CoordinatorOptions): Coordinator;

package/dist/coordinator.js

@@ -0,0 +1,56 @@
+export class CoordinatorError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CoordinatorError";
+    }
+}
+export function createCoordinator(options) {
+    const { reducers, effectHandlers = {}, effectExecutor, maxDispatchDepth = 100, } = options;
+    function isPromiseLike(value) {
+        return typeof value === "object" && value !== null && "then" in value;
+    }
+    async function executeEffect(effect, depth) {
+        if (effect.type === "DISPATCH_EVENT") {
+            const dispatchEffect = effect;
+            const derivedEvent = dispatchEffect.payload.event;
+            if (!derivedEvent) {
+                throw new CoordinatorError("DISPATCH_EVENT effect missing payload.event");
+            }
+            await dispatchAtDepth(derivedEvent, depth + 1);
+            return;
+        }
+        const specificHandler = effectHandlers[effect.type];
+        if (specificHandler) {
+            const handled = specificHandler(effect);
+            if (isPromiseLike(handled))
+                await handled;
+            return;
+        }
+        if (effectExecutor) {
+            const handled = effectExecutor(effect);
+            if (isPromiseLike(handled))
+                await handled;
+        }
+    }
+    async function dispatchAtDepth(event, depth) {
+        if (depth > maxDispatchDepth) {
+            throw new CoordinatorError(`Maximum dispatch depth exceeded (${maxDispatchDepth})`);
+        }
+        const effects = [];
+        for (const reducer of reducers) {
+            const emitted = reducer(event);
+            const resolved = isPromiseLike(emitted) ? await emitted : emitted;
+            if (!resolved || resolved.length === 0)
+                continue;
+            effects.push(...resolved);
+        }
+        for (const effect of effects) {
+            await executeEffect(effect, depth);
+        }
+    }
+    return {
+        async dispatch(event) {
+            await dispatchAtDepth(event, 1);
+        },
+    };
+}

package/dist/goal-coordinator.d.ts

@@ -0,0 +1,22 @@
+import type { ReducerEffect, ReducerEvent } from "./coordinator.js";
+import type { GoalReducerState } from "./goal-types.js";
+import type { LoopReducerState } from "./loop-reducer.js";
+import type { MonitorReducerState } from "./monitor-reducer.js";
+import type { TaskReducerState } from "./task-reducer.js";
+export type GoalVerificationRequestedEvent = ReducerEvent<"GOAL_VERIFICATION_REQUESTED", {
+    id: string;
+}>;
+export interface GoalCoordinatorSnapshot {
+    goalState: GoalReducerState;
+    taskState: TaskReducerState;
+    loopState: LoopReducerState;
+    monitorState: MonitorReducerState;
+}
+export declare function reduceGoalVerificationRequest(event: GoalVerificationRequestedEvent, snapshot: GoalCoordinatorSnapshot): ReducerEffect[];
+export interface GoalCoordinatorOptions {
+    getGoalState: () => GoalReducerState;
+    getTaskState: () => TaskReducerState;
+    getLoopState: () => LoopReducerState;
+    getMonitorState: () => MonitorReducerState;
+}
+export declare function createGoalCoordinatorReducer(options: GoalCoordinatorOptions): (event: ReducerEvent) => ReducerEffect[];

package/dist/goal-coordinator.js

@@ -0,0 +1,28 @@
+import { verifyGoal } from "./goal-verifier.js";
+export function reduceGoalVerificationRequest(event, snapshot) {
+    if (event.type !== "GOAL_VERIFICATION_REQUESTED")
+        return [];
+    const goal = snapshot.goalState.goalsById[event.payload.id];
+    if (!goal)
+        return [];
+    return verifyGoal({
+        goal,
+        taskState: snapshot.taskState,
+        loopState: snapshot.loopState,
+        monitorState: snapshot.monitorState,
+        at: event.at,
+    }).effects;
+}
+export function createGoalCoordinatorReducer(options) {
+    const { getGoalState, getTaskState, getLoopState, getMonitorState } = options;
+    return (event) => {
+        if (event.type !== "GOAL_VERIFICATION_REQUESTED")
+            return [];
+        return reduceGoalVerificationRequest(event, {
+            goalState: getGoalState(),
+            taskState: getTaskState(),
+            loopState: getLoopState(),
+            monitorState: getMonitorState(),
+        });
+    };
+}

package/dist/goal-reducer.d.ts

@@ -0,0 +1,89 @@
+import type { GoalCriteria, GoalEntry, GoalProgressSnapshot, GoalReducerState, GoalScope } from "./goal-types.js";
+export type GoalReducerEvent = {
+    type: "GOAL_CREATED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "goal";
+    entityId?: string;
+    payload: {
+        title: string;
+        description: string;
+        scope: GoalScope;
+        criteria: GoalCriteria;
+        metadata?: Record<string, unknown>;
+    };
+} | {
+    type: "GOAL_ACTIVATED" | "GOAL_VERIFICATION_STARTED" | "GOAL_UNBLOCKED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "goal";
+    entityId?: string;
+    payload: {
+        id: string;
+    };
+} | {
+    type: "GOAL_PROGRESS_RECORDED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "goal";
+    entityId?: string;
+    payload: {
+        id: string;
+        progress: GoalProgressSnapshot;
+    };
+} | {
+    type: "GOAL_VERIFICATION_PASSED" | "GOAL_VERIFICATION_FAILED" | "GOAL_BLOCKED" | "GOAL_FAILED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "goal";
+    entityId?: string;
+    payload: {
+        id: string;
+        reason: string;
+        progress?: GoalProgressSnapshot;
+    };
+} | {
+    type: "GOAL_SATISFIED" | "GOAL_ARCHIVED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "goal";
+    entityId?: string;
+    payload: {
+        id: string;
+        reason?: string;
+    };
+} | {
+    type: "GOAL_UPDATED";
+    at: number;
+    source: "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
+    entityType?: "goal";
+    entityId?: string;
+    payload: {
+        id: string;
+        title?: string;
+        description?: string;
+        scope?: GoalScope;
+        criteria?: GoalCriteria;
+        metadata?: Record<string, unknown>;
+    };
+};
+export type GoalReducerEffect = {
+    type: "PERSIST_GOAL";
+    entityType: "goal";
+    entityId: string;
+    payload: {
+        goal: GoalEntry;
+    };
+} | {
+    type: "REQUEST_GOAL_VERIFICATION";
+    entityType: "goal";
+    entityId: string;
+    payload: {
+        id: string;
+    };
+};
+export interface GoalReduceResult {
+    state: GoalReducerState;
+    effects: GoalReducerEffect[];
+}
+export declare function reduceGoalState(state: GoalReducerState, event: GoalReducerEvent): GoalReduceResult;