@trevonistrevon/pi-loop 0.5.4 → 0.5.6

package/dist/goal-store.js

@@ -1,136 +1,23 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, isAbsolute, join } from "node:path";
+import { join } from "node:path";
 import { reduceGoalState } from "./goal-reducer.js";
+import { ReducerBackedStore } from "./reducer-backed-store.js";
 const GOALS_DIR = join(homedir(), ".pi", "goals");
-const LOCK_RETRY_MS = 50;
-const LOCK_MAX_RETRIES = 100;
 const MAX_GOALS = 200;
-function acquireLock(lockPath) {
-    mkdirSync(dirname(lockPath), { recursive: true });
-    for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
-        try {
-            writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
-            return;
-        }
-        catch (e) {
-            if (e.code === "EEXIST") {
-                try {
-                    const pid = parseInt(readFileSync(lockPath, "utf-8"), 10);
-                    if (!pid || !isProcessRunning(pid)) {
-                        try {
-                            unlinkSync(lockPath);
-                        }
-                        catch { /* ignore */ }
-                        continue;
-                    }
-                }
-                catch { /* ignore read errors */ }
-                const start = Date.now();
-                while (Date.now() - start < LOCK_RETRY_MS) { /* busy wait */ }
-                continue;
-            }
-            throw e;
-        }
-    }
-    throw new Error(`Failed to acquire lock: ${lockPath}`);
-}
-function releaseLock(lockPath) {
-    try {
-        unlinkSync(lockPath);
-    }
-    catch { /* ignore */ }
-}
-function isProcessRunning(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export class GoalStore {
-    filePath;
-    lockPath;
-    lastLoadedSignature;
-    nextId = 1;
-    goals = new Map();
+export class GoalStore extends ReducerBackedStore {
     constructor(listIdOrPath) {
-        if (!listIdOrPath)
-            return;
-        const isAbsPath = isAbsolute(listIdOrPath);
-        const filePath = isAbsPath ? listIdOrPath : join(GOALS_DIR, `${listIdOrPath}.json`);
-        mkdirSync(dirname(filePath), { recursive: true });
-        this.filePath = filePath;
-        this.lockPath = filePath + ".lock";
-        this.load();
-    }
-    getFileSignature() {
-        if (!this.filePath || !existsSync(this.filePath))
-            return undefined;
-        const stat = statSync(this.filePath);
-        return `${stat.mtimeMs}:${stat.size}`;
-    }
-    load(force = false) {
-        if (!this.filePath)
-            return;
-        const signature = this.getFileSignature();
-        if (!signature)
-            return;
-        if (!force && signature === this.lastLoadedSignature)
-            return;
-        try {
-            const data = JSON.parse(readFileSync(this.filePath, "utf-8"));
-            this.nextId = data.nextId;
-            this.goals.clear();
-            for (const goal of data.goals) {
-                this.goals.set(goal.id, goal);
-            }
-            this.lastLoadedSignature = signature;
-        }
-        catch { /* corrupt file — start fresh */ }
-    }
-    save() {
-        if (!this.filePath)
-            return;
-        const data = {
-            nextId: this.nextId,
-            goals: Array.from(this.goals.values()),
-        };
-        const tmpPath = this.filePath + ".tmp";
-        writeFileSync(tmpPath, JSON.stringify(data, null, 2));
-        renameSync(tmpPath, this.filePath);
-        this.lastLoadedSignature = this.getFileSignature();
-    }
-    withLock(fn) {
-        if (!this.lockPath)
-            return fn();
-        acquireLock(this.lockPath);
-        try {
-            this.load(true);
-            const result = fn();
-            this.save();
-            return result;
-        }
-        finally {
-            releaseLock(this.lockPath);
-        }
-    }
-    toReducerState() {
-        return {
-            nextId: this.nextId,
-            goalsById: Object.fromEntries(this.goals.entries()),
-        };
-    }
-    applyReducerEvent(event) {
-        const result = reduceGoalState(this.toReducerState(), event);
-        this.nextId = result.state.nextId;
-        this.goals = new Map(Object.entries(result.state.goalsById));
+        super({
+            baseDir: GOALS_DIR,
+            reduce: (state, event) => reduceGoalState(state, event),
+            toReducerState: (nextId, entries) => ({ nextId, goalsById: Object.fromEntries(entries.entries()) }),
+            fromReducerState: (state) => ({ nextId: state.nextId, entries: new Map(Object.entries(state.goalsById)) }),
+            serialize: (nextId, entries) => ({ nextId, goals: Array.from(entries.values()) }),
+            deserialize: (data) => ({ nextId: data.nextId, entries: new Map(data.goals.map((g) => [g.id, g])) }),
+        }, listIdOrPath);
     }
     create(title, description, scope, criteria, metadata) {
         return this.withLock(() => {
-            if (this.goals.size >= MAX_GOALS) {
+            if (this.entries.size >= MAX_GOALS) {
                 throw new Error(`Maximum of ${MAX_GOALS} goals reached. Archive some before creating new ones.`);
             }
             this.applyReducerEvent({
@@ -146,22 +33,12 @@ export class GoalStore {
                     metadata,
                 },
             });
-            return this.goals.get(String(this.nextId - 1));
+            return this.entries.get(String(this.nextId - 1));
         });
     }
-    get(id) {
-        if (this.filePath)
-            this.load();
-        return this.goals.get(id);
-    }
-    list() {
-        if (this.filePath)
-            this.load();
-        return Array.from(this.goals.values()).sort((a, b) => Number(a.id) - Number(b.id));
-    }
     activate(id) {
         return this.withLock(() => {
-            if (!this.goals.has(id))
+            if (!this.entries.has(id))
                 return undefined;
             this.applyReducerEvent({
                 type: "GOAL_ACTIVATED",
@@ -171,12 +48,12 @@ export class GoalStore {
                 entityId: id,
                 payload: { id },
             });
-            return this.goals.get(id);
+            return this.entries.get(id);
         });
     }
     recordProgress(id, progress) {
         return this.withLock(() => {
-            if (!this.goals.has(id))
+            if (!this.entries.has(id))
                 return undefined;
             this.applyReducerEvent({
                 type: "GOAL_PROGRESS_RECORDED",
@@ -186,12 +63,12 @@ export class GoalStore {
                 entityId: id,
                 payload: { id, progress },
             });
-            return this.goals.get(id);
+            return this.entries.get(id);
         });
     }
     markVerificationStarted(id) {
         return this.withLock(() => {
-            if (!this.goals.has(id))
+            if (!this.entries.has(id))
                 return undefined;
             this.applyReducerEvent({
                 type: "GOAL_VERIFICATION_STARTED",
@@ -201,12 +78,12 @@ export class GoalStore {
                 entityId: id,
                 payload: { id },
             });
-            return this.goals.get(id);
+            return this.entries.get(id);
         });
     }
     markVerified(id, reason, progress) {
         return this.withLock(() => {
-            if (!this.goals.has(id))
+            if (!this.entries.has(id))
                 return undefined;
             this.applyReducerEvent({
                 type: "GOAL_VERIFICATION_PASSED",
@@ -216,12 +93,12 @@ export class GoalStore {
                 entityId: id,
                 payload: { id, reason, progress },
             });
-            return this.goals.get(id);
+            return this.entries.get(id);
         });
     }
     markFailed(id, reason, progress) {
         return this.withLock(() => {
-            if (!this.goals.has(id))
+            if (!this.entries.has(id))
                 return undefined;
             this.applyReducerEvent({
                 type: "GOAL_FAILED",
@@ -231,12 +108,12 @@ export class GoalStore {
                 entityId: id,
                 payload: { id, reason, progress },
             });
-            return this.goals.get(id);
+            return this.entries.get(id);
         });
     }
     markBlocked(id, reason, progress) {
         return this.withLock(() => {
-            if (!this.goals.has(id))
+            if (!this.entries.has(id))
                 return undefined;
             this.applyReducerEvent({
                 type: "GOAL_BLOCKED",
@@ -246,12 +123,12 @@ export class GoalStore {
                 entityId: id,
                 payload: { id, reason, progress },
             });
-            return this.goals.get(id);
+            return this.entries.get(id);
         });
     }
     unblock(id) {
         return this.withLock(() => {
-            if (!this.goals.has(id))
+            if (!this.entries.has(id))
                 return undefined;
             this.applyReducerEvent({
                 type: "GOAL_UNBLOCKED",
@@ -261,19 +138,19 @@ export class GoalStore {
                 entityId: id,
                 payload: { id },
             });
-            return this.goals.get(id);
+            return this.entries.get(id);
         });
     }
     updateDetails(id, fields) {
         return this.withLock(() => {
-            if (!this.goals.has(id))
+            if (!this.entries.has(id))
                 return undefined;
             if (fields.title === undefined
                 && fields.description === undefined
                 && fields.scope === undefined
                 && fields.criteria === undefined
                 && fields.metadata === undefined) {
-                return this.goals.get(id);
+                return this.entries.get(id);
             }
             this.applyReducerEvent({
                 type: "GOAL_UPDATED",
@@ -290,12 +167,12 @@ export class GoalStore {
                     metadata: fields.metadata,
                 },
             });
-            return this.goals.get(id);
+            return this.entries.get(id);
         });
     }
     archive(id, reason) {
         return this.withLock(() => {
-            if (!this.goals.has(id))
+            if (!this.entries.has(id))
                 return undefined;
             this.applyReducerEvent({
                 type: "GOAL_ARCHIVED",
@@ -305,7 +182,7 @@ export class GoalStore {
                 entityId: id,
                 payload: { id, reason },
             });
-            return this.goals.get(id);
+            return this.entries.get(id);
         });
     }
 }

package/dist/index.js

@@ -15,6 +15,7 @@
  */
 import { registerLoopCommand } from "./commands/loop-command.js";
 import { registerTasksCommand } from "./commands/tasks-command.js";
+import { atMaxFires } from "./loop-reducer.js";
 import { MonitorManager } from "./monitor-manager.js";
 import { createMonitorOnDoneRuntime } from "./runtime/monitor-ondone-runtime.js";
 import { createNotificationRuntime, } from "./runtime/notification-runtime.js";
@@ -45,6 +46,9 @@ export default function (pi) {
     let scheduler;
     let triggerSystem;
     const widget = new LoopWidget(store, monitorManager);
+    // Repaint the status bar when a monitor finishes/prunes on its own (no tool
+    // call), so stale monitors don't linger in the count between turns.
+    monitorManager.setOnChange(() => widget.update());
     widget.setTaskSummaryProvider(() => {
         if (!nativeTaskStore)
             return { count: 0 };
@@ -158,7 +162,7 @@ export default function (pi) {
     // ── Loop fire handler ──
     function onLoopFire(entry) {
         debug(`loop:fire #${entry.id}`, { prompt: entry.prompt.slice(0, 50) });
-        if (entry.maxFires && (entry.fireCount ?? 0) >= entry.maxFires) {
+        if (atMaxFires(entry)) {
             debug(`loop #${entry.id} — reached maxFires ${entry.maxFires}, expiring`);
             store.delete(entry.id);
             return;

package/dist/loop-reducer.d.ts

@@ -1,5 +1,12 @@
 import type { LoopEntry, Trigger } from "./types.js";
 export declare const MAX_LOOP_EXPIRY_MS: number;
+/**
+ * Whether a loop has reached its fire cap. Single source of truth for the
+ * `maxFires` check shared by the fire callbacks (`onLoopFire` pre-fire guard and
+ * `TriggerSystem.fireLoop` post-fire cleanup). Each caller keeps its own timing;
+ * only the predicate is shared.
+ */
+export declare function atMaxFires(loop: Pick<LoopEntry, "maxFires" | "fireCount">): boolean;
 type ReducerSource = "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
 export interface LoopReducerState {
     nextId: number;

package/dist/loop-reducer.js

@@ -1,4 +1,13 @@
 export const MAX_LOOP_EXPIRY_MS = 7 * 24 * 60 * 60 * 1000;
+/**
+ * Whether a loop has reached its fire cap. Single source of truth for the
+ * `maxFires` check shared by the fire callbacks (`onLoopFire` pre-fire guard and
+ * `TriggerSystem.fireLoop` post-fire cleanup). Each caller keeps its own timing;
+ * only the predicate is shared.
+ */
+export function atMaxFires(loop) {
+    return !!loop.maxFires && (loop.fireCount ?? 0) >= loop.maxFires;
+}
 function cloneState(state) {
     return {
         nextId: state.nextId,

package/dist/monitor-manager.d.ts

@@ -4,9 +4,18 @@ export declare class MonitorManager {
     private pi;
     private processes;
     private nextId;
+    private onChange;
     constructor(pi: ExtensionAPI);
+    /**
+     * Register a callback fired when a monitor's status changes or it is pruned
+     * (e.g. autonomous completion/error/stop/prune with no tool call). Used to
+     * repaint the status widget, which otherwise only refreshes on turn
+     * boundaries and explicit tool actions. Not fired for output lines.
+     */
+    setOnChange(cb: () => void): void;
     private toReducerState;
     private applyReducerEvent;
+    private schedulePrune;
     create(command: string, description?: string, timeout?: number): MonitorEntry;
     get(id: string): MonitorEntry | undefined;
     list(): MonitorEntry[];

package/dist/monitor-manager.js

@@ -4,9 +4,19 @@ export class MonitorManager {
     pi;
     processes = new Map();
     nextId = 1;
+    onChange;
     constructor(pi) {
         this.pi = pi;
     }
+    /**
+     * Register a callback fired when a monitor's status changes or it is pruned
+     * (e.g. autonomous completion/error/stop/prune with no tool call). Used to
+     * repaint the status widget, which otherwise only refreshes on turn
+     * boundaries and explicit tool actions. Not fired for output lines.
+     */
+    setOnChange(cb) {
+        this.onChange = cb;
+    }
     toReducerState() {
         return {
             nextId: this.nextId,
@@ -24,8 +34,29 @@ export class MonitorManager {
             }
             process.entry = updated;
         }
+        // Repaint on status/set transitions, but not on the frequent output-line
+        // events (which never change the visible count).
+        if (event.type !== "MONITOR_OUTPUT" && event.type !== "MONITOR_ONDONE_REGISTERED") {
+            this.onChange?.();
+        }
         return result;
     }
+    // Remove a finished monitor (completed/errored/stopped) after a brief delay so
+    // tool consumers can still read its final state via MonitorList. Shared by
+    // finish() and stop() so every terminal status is pruned consistently — a
+    // stopped monitor that is never pruned lingers in list() and the widget count.
+    schedulePrune(id) {
+        setTimeout(() => {
+            this.applyReducerEvent({
+                type: "MONITOR_PRUNED",
+                at: Date.now(),
+                source: "system",
+                entityType: "monitor",
+                entityId: id,
+                payload: { id },
+            });
+        }, 30000);
+    }
     create(command, description, timeout = 300000) {
         const now = Date.now();
         const result = reduceMonitorState(this.toReducerState(), {
@@ -120,18 +151,7 @@ export class MonitorManager {
             for (const resolve of bp.waiters)
                 resolve();
             bp.waiters = [];
-            // Remove completed/errored monitors after a brief delay so tool
-            // consumers have time to read the final state via MonitorList.
-            setTimeout(() => {
-                this.applyReducerEvent({
-                    type: "MONITOR_PRUNED",
-                    at: Date.now(),
-                    source: "system",
-                    entityType: "monitor",
-                    entityId: id,
-                    payload: { id },
-                });
-            }, 30000);
+            this.schedulePrune(id);
         };
         child.on("close", (code) => {
             if (bp.entry.status === "running") {
@@ -197,6 +217,7 @@ export class MonitorManager {
                 reason: "manual",
             },
         });
+        this.schedulePrune(id);
         bp.proc.kill("SIGTERM");
         await new Promise((resolve) => {
             const timer = setTimeout(() => {

package/dist/reducer-backed-store.d.ts

@@ -0,0 +1,65 @@
+import type { AnyReducerEffect } from "./coordinator.js";
+export interface ReducerResult<TState> {
+    state: TState;
+    effects: AnyReducerEffect[];
+}
+/**
+ * Per-store glue the base needs to translate between its internal
+ * `{ nextId, entries }` representation, the pure reducer's state shape, and the
+ * on-disk JSON shape. Each is a small, allocation-only function.
+ */
+export interface ReducerBackedStoreConfig<TEntry, TState, TEvent, TData> {
+    /** Directory for `<listId>.json` when constructed with a bare list id. */
+    baseDir: string;
+    reduce: (state: TState, event: TEvent) => ReducerResult<TState>;
+    toReducerState: (nextId: number, entries: Map<string, TEntry>) => TState;
+    fromReducerState: (state: TState) => {
+        nextId: number;
+        entries: Map<string, TEntry>;
+    };
+    serialize: (nextId: number, entries: Map<string, TEntry>) => TData;
+    deserialize: (data: TData) => {
+        nextId: number;
+        entries: Map<string, TEntry>;
+    };
+}
+/**
+ * Shared persistence + reducer-dispatch machinery for the file-backed entity
+ * stores (loops, tasks, goals). Owns file locking, signature-gated load, atomic
+ * save, and reducer application; subclasses add only their entity-specific
+ * command methods.
+ *
+ * Durability boundary: every mutation runs inside {@link withLock}, which saves
+ * the whole file unconditionally after the callback. Reducer effects are
+ * therefore *not* the persistence mechanism — they are surfaced to
+ * {@link onEffects} (default: no-op) so cross-entity effects (e.g.
+ * `DISPATCH_EVENT`, `REQUEST_GOAL_VERIFICATION`) can be forwarded by the runtime
+ * without being silently dropped at the reducer call site.
+ */
+export declare abstract class ReducerBackedStore<TEntry extends {
+    id: string;
+}, TState, TEvent, TData> {
+    protected filePath: string | undefined;
+    protected lockPath: string | undefined;
+    private lastLoadedSignature;
+    protected nextId: number;
+    protected entries: Map<string, TEntry>;
+    private readonly config;
+    constructor(config: ReducerBackedStoreConfig<TEntry, TState, TEvent, TData>, listIdOrPath?: string);
+    private getFileSignature;
+    private load;
+    private save;
+    protected withLock<T>(fn: () => T): T;
+    protected applyReducerEvent(event: TEvent): void;
+    /**
+     * Hook for reducer effects. Default no-op: durability is owned by
+     * {@link withLock}. Override to forward non-persistence effects.
+     */
+    protected onEffects(_effects: AnyReducerEffect[]): void;
+    /** Reload (signature-gated) and return the entry, or undefined. */
+    get(id: string): TEntry | undefined;
+    /** Reload (signature-gated) and return all entries sorted by numeric id. */
+    list(): TEntry[];
+    /** Remove the backing file when the store is empty. No-op for memory stores. */
+    deleteFileIfEmpty(): boolean;
+}

package/dist/reducer-backed-store.js

@@ -0,0 +1,160 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join } from "node:path";
+const LOCK_RETRY_MS = 50;
+const LOCK_MAX_RETRIES = 100;
+function acquireLock(lockPath) {
+    mkdirSync(dirname(lockPath), { recursive: true });
+    for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
+        try {
+            writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
+            return;
+        }
+        catch (e) {
+            if (e.code === "EEXIST") {
+                try {
+                    const pid = parseInt(readFileSync(lockPath, "utf-8"), 10);
+                    if (!pid || !isProcessRunning(pid)) {
+                        try {
+                            unlinkSync(lockPath);
+                        }
+                        catch { /* ignore */ }
+                        continue;
+                    }
+                }
+                catch { /* ignore read errors */ }
+                const start = Date.now();
+                while (Date.now() - start < LOCK_RETRY_MS) { /* busy wait */ }
+                continue;
+            }
+            throw e;
+        }
+    }
+    throw new Error(`Failed to acquire lock: ${lockPath}`);
+}
+function releaseLock(lockPath) {
+    try {
+        unlinkSync(lockPath);
+    }
+    catch { /* ignore */ }
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Shared persistence + reducer-dispatch machinery for the file-backed entity
+ * stores (loops, tasks, goals). Owns file locking, signature-gated load, atomic
+ * save, and reducer application; subclasses add only their entity-specific
+ * command methods.
+ *
+ * Durability boundary: every mutation runs inside {@link withLock}, which saves
+ * the whole file unconditionally after the callback. Reducer effects are
+ * therefore *not* the persistence mechanism — they are surfaced to
+ * {@link onEffects} (default: no-op) so cross-entity effects (e.g.
+ * `DISPATCH_EVENT`, `REQUEST_GOAL_VERIFICATION`) can be forwarded by the runtime
+ * without being silently dropped at the reducer call site.
+ */
+export class ReducerBackedStore {
+    filePath;
+    lockPath;
+    lastLoadedSignature;
+    nextId = 1;
+    entries = new Map();
+    config;
+    constructor(config, listIdOrPath) {
+        this.config = config;
+        if (!listIdOrPath)
+            return;
+        const filePath = isAbsolute(listIdOrPath) ? listIdOrPath : join(config.baseDir, `${listIdOrPath}.json`);
+        mkdirSync(dirname(filePath), { recursive: true });
+        this.filePath = filePath;
+        this.lockPath = `${filePath}.lock`;
+        this.load();
+    }
+    getFileSignature() {
+        if (!this.filePath || !existsSync(this.filePath))
+            return undefined;
+        const stat = statSync(this.filePath);
+        return `${stat.mtimeMs}:${stat.size}`;
+    }
+    load(force = false) {
+        if (!this.filePath)
+            return;
+        const signature = this.getFileSignature();
+        if (!signature)
+            return;
+        if (!force && signature === this.lastLoadedSignature)
+            return;
+        try {
+            const data = JSON.parse(readFileSync(this.filePath, "utf-8"));
+            const { nextId, entries } = this.config.deserialize(data);
+            this.nextId = nextId;
+            this.entries = entries;
+            this.lastLoadedSignature = signature;
+        }
+        catch { /* corrupt file — start fresh */ }
+    }
+    save() {
+        if (!this.filePath)
+            return;
+        const data = this.config.serialize(this.nextId, this.entries);
+        const tmpPath = `${this.filePath}.tmp`;
+        writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+        renameSync(tmpPath, this.filePath);
+        this.lastLoadedSignature = this.getFileSignature();
+    }
+    withLock(fn) {
+        if (!this.lockPath)
+            return fn();
+        acquireLock(this.lockPath);
+        try {
+            this.load(true);
+            const result = fn();
+            this.save();
+            return result;
+        }
+        finally {
+            releaseLock(this.lockPath);
+        }
+    }
+    applyReducerEvent(event) {
+        const result = this.config.reduce(this.config.toReducerState(this.nextId, this.entries), event);
+        const { nextId, entries } = this.config.fromReducerState(result.state);
+        this.nextId = nextId;
+        this.entries = entries;
+        if (result.effects.length > 0)
+            this.onEffects(result.effects);
+    }
+    /**
+     * Hook for reducer effects. Default no-op: durability is owned by
+     * {@link withLock}. Override to forward non-persistence effects.
+     */
+    onEffects(_effects) { }
+    /** Reload (signature-gated) and return the entry, or undefined. */
+    get(id) {
+        if (this.filePath)
+            this.load();
+        return this.entries.get(id);
+    }
+    /** Reload (signature-gated) and return all entries sorted by numeric id. */
+    list() {
+        if (this.filePath)
+            this.load();
+        return Array.from(this.entries.values()).sort((a, b) => Number(a.id) - Number(b.id));
+    }
+    /** Remove the backing file when the store is empty. No-op for memory stores. */
+    deleteFileIfEmpty() {
+        if (!this.filePath || this.entries.size > 0)
+            return false;
+        try {
+            unlinkSync(this.filePath);
+        }
+        catch { /* ignore */ }
+        return true;
+    }
+}