@trevonistrevon/pi-loop 0.5.0 → 0.5.1

package/README.md

@@ -77,37 +77,38 @@ 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
 
@@ -117,7 +118,7 @@ Keep `PI_LOOP_SCOPE=session` as the default.
 - `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.
 
-This matches the current wake model well: pending notifications stay in memory and are cancelable, while durable loop/task intent remains scoped per session.
+
 
 ## 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/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;

package/dist/goal-reducer.js

@@ -0,0 +1,181 @@
+function cloneState(state) {
+    return {
+        nextId: state.nextId,
+        goalsById: { ...state.goalsById },
+    };
+}
+function emptyProgress() {
+    return {
+        totalTasks: 0,
+        pendingTasks: 0,
+        inProgressTasks: 0,
+        completedTasks: 0,
+        activeLoops: 0,
+        pausedLoops: 0,
+        runningMonitors: 0,
+        completedMonitors: 0,
+        erroredMonitors: 0,
+        stoppedMonitors: 0,
+    };
+}
+function emptyVerification() {
+    return {
+        attempts: 0,
+        passes: 0,
+        failures: 0,
+    };
+}
+function persist(goal) {
+    return {
+        type: "PERSIST_GOAL",
+        entityType: "goal",
+        entityId: goal.id,
+        payload: { goal },
+    };
+}
+function isTerminal(goal) {
+    return goal.status === "satisfied" || goal.status === "failed" || goal.status === "archived";
+}
+export function reduceGoalState(state, event) {
+    if (event.type === "GOAL_CREATED") {
+        const next = cloneState(state);
+        const id = String(next.nextId++);
+        const goal = {
+            id,
+            title: event.payload.title,
+            description: event.payload.description,
+            status: "pending",
+            verificationStatus: "unknown",
+            createdAt: event.at,
+            updatedAt: event.at,
+            scope: event.payload.scope,
+            criteria: event.payload.criteria,
+            progress: emptyProgress(),
+            verification: emptyVerification(),
+            metadata: event.payload.metadata,
+        };
+        next.goalsById[id] = goal;
+        return {
+            state: next,
+            effects: [persist(goal)],
+        };
+    }
+    const id = event.payload.id;
+    const current = state.goalsById[id];
+    if (!current)
+        return { state, effects: [] };
+    if (isTerminal(current) && event.type !== "GOAL_ARCHIVED")
+        return { state, effects: [] };
+    const next = cloneState(state);
+    const goal = {
+        ...current,
+        progress: { ...current.progress },
+        verification: { ...current.verification },
+    };
+    let extraEffects = [];
+    if (event.type === "GOAL_ACTIVATED") {
+        goal.status = "active";
+        goal.activatedAt ??= event.at;
+        goal.updatedAt = event.at;
+        extraEffects = [{
+                type: "REQUEST_GOAL_VERIFICATION",
+                entityType: "goal",
+                entityId: id,
+                payload: { id },
+            }];
+    }
+    if (event.type === "GOAL_PROGRESS_RECORDED") {
+        goal.progress = event.payload.progress;
+        goal.updatedAt = event.at;
+    }
+    if (event.type === "GOAL_VERIFICATION_STARTED") {
+        goal.verificationStatus = "checking";
+        goal.verification.attempts += 1;
+        goal.verification.lastCheckedAt = event.at;
+        goal.updatedAt = event.at;
+    }
+    if (event.type === "GOAL_VERIFICATION_PASSED") {
+        if (event.payload.progress)
+            goal.progress = event.payload.progress;
+        goal.status = "satisfied";
+        goal.verificationStatus = "verified";
+        goal.verification.passes += 1;
+        goal.verification.lastPassedAt = event.at;
+        goal.verification.lastCheckedAt = event.at;
+        goal.verification.lastReason = event.payload.reason;
+        goal.resolvedAt = event.at;
+        goal.updatedAt = event.at;
+    }
+    if (event.type === "GOAL_VERIFICATION_FAILED") {
+        if (event.payload.progress)
+            goal.progress = event.payload.progress;
+        goal.verificationStatus = "unverified";
+        goal.verification.failures += 1;
+        goal.verification.lastFailedAt = event.at;
+        goal.verification.lastCheckedAt = event.at;
+        goal.verification.lastReason = event.payload.reason;
+        if (goal.status === "pending")
+            goal.status = "active";
+        goal.updatedAt = event.at;
+    }
+    if (event.type === "GOAL_BLOCKED") {
+        if (event.payload.progress)
+            goal.progress = event.payload.progress;
+        goal.status = "blocked";
+        goal.verificationStatus = "inconclusive";
+        goal.verification.failures += 1;
+        goal.verification.lastFailedAt = event.at;
+        goal.verification.lastCheckedAt = event.at;
+        goal.verification.lastReason = event.payload.reason;
+        goal.updatedAt = event.at;
+    }
+    if (event.type === "GOAL_UNBLOCKED") {
+        goal.status = "active";
+        goal.updatedAt = event.at;
+    }
+    if (event.type === "GOAL_SATISFIED") {
+        goal.status = "satisfied";
+        goal.verificationStatus = "verified";
+        goal.verification.lastReason = event.payload.reason ?? goal.verification.lastReason;
+        goal.resolvedAt = event.at;
+        goal.updatedAt = event.at;
+    }
+    if (event.type === "GOAL_FAILED") {
+        if (event.payload.progress)
+            goal.progress = event.payload.progress;
+        goal.status = "failed";
+        goal.verificationStatus = "unverified";
+        goal.verification.failures += 1;
+        goal.verification.lastFailedAt = event.at;
+        goal.verification.lastCheckedAt = event.at;
+        goal.verification.lastReason = event.payload.reason;
+        goal.resolvedAt = event.at;
+        goal.updatedAt = event.at;
+    }
+    if (event.type === "GOAL_ARCHIVED") {
+        goal.status = "archived";
+        goal.resolvedAt = event.at;
+        goal.updatedAt = event.at;
+        if (event.payload.reason !== undefined) {
+            goal.verification.lastReason = event.payload.reason;
+        }
+    }
+    if (event.type === "GOAL_UPDATED") {
+        if (event.payload.title !== undefined)
+            goal.title = event.payload.title;
+        if (event.payload.description !== undefined)
+            goal.description = event.payload.description;
+        if (event.payload.scope !== undefined)
+            goal.scope = event.payload.scope;
+        if (event.payload.criteria !== undefined)
+            goal.criteria = event.payload.criteria;
+        if (event.payload.metadata !== undefined)
+            goal.metadata = event.payload.metadata;
+        goal.updatedAt = event.at;
+    }
+    next.goalsById[id] = goal;
+    return {
+        state: next,
+        effects: [persist(goal), ...extraEffects],
+    };
+}