@trevonistrevon/pi-loop 0.5.4 → 0.5.6

package/src/goal-reducer.ts

@@ -82,6 +82,15 @@ export type GoalReducerEffect =
     entityType: "goal";
     entityId: string;
     payload: { id: string };
+  }
+  | {
+    // Diagnostic: a transition was dropped because the goal is in a terminal
+    // state. Surfaced (rather than silently ignored) so the effect sink can log
+    // it. Carries no state change.
+    type: "GOAL_TRANSITION_REJECTED";
+    entityType: "goal";
+    entityId: string;
+    payload: { id: string; status: GoalEntry["status"]; attempted: string };
   };
 
 export interface GoalReduceResult {
@@ -160,7 +169,17 @@ export function reduceGoalState(state: GoalReducerState, event: GoalReducerEvent
   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: [] };
+  if (isTerminal(current) && event.type !== "GOAL_ARCHIVED") {
+    return {
+      state,
+      effects: [{
+        type: "GOAL_TRANSITION_REJECTED",
+        entityType: "goal",
+        entityId: id,
+        payload: { id, status: current.status, attempted: event.type },
+      }],
+    };
+  }
 
   const next = cloneState(state);
   const goal: GoalEntry = {

package/src/goal-store.ts

@@ -1,6 +1,5 @@
-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 { type GoalReducerEvent, reduceGoalState } from "./goal-reducer.js";
 import type {
   GoalCriteria,
@@ -10,121 +9,24 @@ import type {
   GoalScope,
   GoalStoreData,
 } from "./goal-types.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: string): void {
-  mkdirSync(dirname(lockPath), { recursive: true });
-  for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
-    try {
-      writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
-      return;
-    } catch (e: any) {
-      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: string): void {
-  try { unlinkSync(lockPath); } catch { /* ignore */ }
-}
-
-function isProcessRunning(pid: number): boolean {
-  try { process.kill(pid, 0); return true; } catch { return false; }
-}
-
-export class GoalStore {
-  private filePath: string | undefined;
-  private lockPath: string | undefined;
-  private lastLoadedSignature: string | undefined;
-
-  private nextId = 1;
-  private goals = new Map<string, GoalEntry>();
-
+export class GoalStore extends ReducerBackedStore<GoalEntry, GoalReducerState, GoalReducerEvent, GoalStoreData> {
   constructor(listIdOrPath?: string) {
-    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();
-  }
-
-  private getFileSignature(): string | undefined {
-    if (!this.filePath || !existsSync(this.filePath)) return undefined;
-    const stat = statSync(this.filePath);
-    return `${stat.mtimeMs}:${stat.size}`;
-  }
-
-  private load(force = false): void {
-    if (!this.filePath) return;
-    const signature = this.getFileSignature();
-    if (!signature) return;
-    if (!force && signature === this.lastLoadedSignature) return;
-    try {
-      const data: GoalStoreData = 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 */ }
-  }
-
-  private save(): void {
-    if (!this.filePath) return;
-    const data: GoalStoreData = {
-      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();
-  }
-
-  private withLock<T>(fn: () => T): T {
-    if (!this.lockPath) return fn();
-    acquireLock(this.lockPath);
-    try {
-      this.load(true);
-      const result = fn();
-      this.save();
-      return result;
-    } finally {
-      releaseLock(this.lockPath);
-    }
-  }
-
-  private toReducerState(): GoalReducerState {
-    return {
-      nextId: this.nextId,
-      goalsById: Object.fromEntries(this.goals.entries()),
-    };
-  }
-
-  private applyReducerEvent(event: GoalReducerEvent): void {
-    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(
@@ -135,7 +37,7 @@ export class GoalStore {
     metadata?: Record<string, unknown>,
   ): GoalEntry {
     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({
@@ -151,23 +53,13 @@ export class GoalStore {
           metadata,
         },
       });
-      return this.goals.get(String(this.nextId - 1))!;
+      return this.entries.get(String(this.nextId - 1))!;
     });
   }
 
-  get(id: string): GoalEntry | undefined {
-    if (this.filePath) this.load();
-    return this.goals.get(id);
-  }
-
-  list(): GoalEntry[] {
-    if (this.filePath) this.load();
-    return Array.from(this.goals.values()).sort((a, b) => Number(a.id) - Number(b.id));
-  }
-
   activate(id: string): GoalEntry | undefined {
     return this.withLock(() => {
-      if (!this.goals.has(id)) return undefined;
+      if (!this.entries.has(id)) return undefined;
       this.applyReducerEvent({
         type: "GOAL_ACTIVATED",
         at: Date.now(),
@@ -176,13 +68,13 @@ export class GoalStore {
         entityId: id,
         payload: { id },
       });
-      return this.goals.get(id);
+      return this.entries.get(id);
     });
   }
 
   recordProgress(id: string, progress: GoalProgressSnapshot): GoalEntry | undefined {
     return this.withLock(() => {
-      if (!this.goals.has(id)) return undefined;
+      if (!this.entries.has(id)) return undefined;
       this.applyReducerEvent({
         type: "GOAL_PROGRESS_RECORDED",
         at: Date.now(),
@@ -191,13 +83,13 @@ export class GoalStore {
         entityId: id,
         payload: { id, progress },
       });
-      return this.goals.get(id);
+      return this.entries.get(id);
     });
   }
 
   markVerificationStarted(id: string): GoalEntry | undefined {
     return this.withLock(() => {
-      if (!this.goals.has(id)) return undefined;
+      if (!this.entries.has(id)) return undefined;
       this.applyReducerEvent({
         type: "GOAL_VERIFICATION_STARTED",
         at: Date.now(),
@@ -206,13 +98,13 @@ export class GoalStore {
         entityId: id,
         payload: { id },
       });
-      return this.goals.get(id);
+      return this.entries.get(id);
     });
   }
 
   markVerified(id: string, reason: string, progress?: GoalProgressSnapshot): GoalEntry | undefined {
     return this.withLock(() => {
-      if (!this.goals.has(id)) return undefined;
+      if (!this.entries.has(id)) return undefined;
       this.applyReducerEvent({
         type: "GOAL_VERIFICATION_PASSED",
         at: Date.now(),
@@ -221,13 +113,13 @@ export class GoalStore {
         entityId: id,
         payload: { id, reason, progress },
       });
-      return this.goals.get(id);
+      return this.entries.get(id);
     });
   }
 
   markFailed(id: string, reason: string, progress?: GoalProgressSnapshot): GoalEntry | undefined {
     return this.withLock(() => {
-      if (!this.goals.has(id)) return undefined;
+      if (!this.entries.has(id)) return undefined;
       this.applyReducerEvent({
         type: "GOAL_FAILED",
         at: Date.now(),
@@ -236,13 +128,13 @@ export class GoalStore {
         entityId: id,
         payload: { id, reason, progress },
       });
-      return this.goals.get(id);
+      return this.entries.get(id);
     });
   }
 
   markBlocked(id: string, reason: string, progress?: GoalProgressSnapshot): GoalEntry | undefined {
     return this.withLock(() => {
-      if (!this.goals.has(id)) return undefined;
+      if (!this.entries.has(id)) return undefined;
       this.applyReducerEvent({
         type: "GOAL_BLOCKED",
         at: Date.now(),
@@ -251,13 +143,13 @@ export class GoalStore {
         entityId: id,
         payload: { id, reason, progress },
       });
-      return this.goals.get(id);
+      return this.entries.get(id);
     });
   }
 
   unblock(id: string): GoalEntry | undefined {
     return this.withLock(() => {
-      if (!this.goals.has(id)) return undefined;
+      if (!this.entries.has(id)) return undefined;
       this.applyReducerEvent({
         type: "GOAL_UNBLOCKED",
         at: Date.now(),
@@ -266,7 +158,7 @@ export class GoalStore {
         entityId: id,
         payload: { id },
       });
-      return this.goals.get(id);
+      return this.entries.get(id);
     });
   }
 
@@ -281,7 +173,7 @@ export class GoalStore {
     },
   ): GoalEntry | undefined {
     return this.withLock(() => {
-      if (!this.goals.has(id)) return undefined;
+      if (!this.entries.has(id)) return undefined;
       if (
         fields.title === undefined
         && fields.description === undefined
@@ -289,7 +181,7 @@ export class GoalStore {
         && fields.criteria === undefined
         && fields.metadata === undefined
       ) {
-        return this.goals.get(id);
+        return this.entries.get(id);
       }
       this.applyReducerEvent({
         type: "GOAL_UPDATED",
@@ -306,13 +198,13 @@ export class GoalStore {
           metadata: fields.metadata,
         },
       });
-      return this.goals.get(id);
+      return this.entries.get(id);
     });
   }
 
   archive(id: string, reason?: string): GoalEntry | undefined {
     return this.withLock(() => {
-      if (!this.goals.has(id)) return undefined;
+      if (!this.entries.has(id)) return undefined;
       this.applyReducerEvent({
         type: "GOAL_ARCHIVED",
         at: Date.now(),
@@ -321,7 +213,7 @@ export class GoalStore {
         entityId: id,
         payload: { id, reason },
       });
-      return this.goals.get(id);
+      return this.entries.get(id);
     });
   }
 }

package/src/index.ts

@@ -17,6 +17,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 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 {
@@ -54,6 +55,9 @@ export default function (pi: ExtensionAPI) {
   let scheduler: CronScheduler;
   let triggerSystem: 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 };
     const tasks = nativeTaskStore.list().filter(t => t.status === "pending" || t.status === "in_progress");
@@ -178,7 +182,7 @@ export default function (pi: ExtensionAPI) {
   function onLoopFire(entry: LoopEntry): void {
     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/src/loop-reducer.ts

@@ -2,6 +2,16 @@ import type { LoopEntry, Trigger } from "./types.js";
 
 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: Pick<LoopEntry, "maxFires" | "fireCount">): boolean {
+  return !!loop.maxFires && (loop.fireCount ?? 0) >= loop.maxFires;
+}
+
 type ReducerSource = "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
 
 export interface LoopReducerState {

package/src/monitor-manager.ts

@@ -11,9 +11,20 @@ import type { MonitorEntry, MonitorProcess } from "./types.js";
 export class MonitorManager {
   private processes = new Map<string, MonitorProcess>();
   private nextId = 1;
+  private onChange: (() => void) | undefined;
 
   constructor(private 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 {
+    this.onChange = cb;
+  }
+
   private toReducerState(): MonitorReducerState {
     return {
       nextId: this.nextId,
@@ -34,9 +45,31 @@ 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.
+  private schedulePrune(id: string): void {
+    setTimeout(() => {
+      this.applyReducerEvent({
+        type: "MONITOR_PRUNED",
+        at: Date.now(),
+        source: "system",
+        entityType: "monitor",
+        entityId: id,
+        payload: { id },
+      });
+    }, 30000);
+  }
+
   create(command: string, description?: string, timeout = 300000): MonitorEntry {
     const now = Date.now();
     const result = reduceMonitorState(this.toReducerState(), {
@@ -132,18 +165,7 @@ export class MonitorManager {
       bp.completionCallbacks = [];
       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) => {
@@ -214,6 +236,7 @@ export class MonitorManager {
         reason: "manual",
       },
     });
+    this.schedulePrune(id);
     bp.proc.kill("SIGTERM");
 
     await new Promise<void>((resolve) => {

package/src/reducer-backed-store.ts

@@ -0,0 +1,168 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join } from "node:path";
+import type { AnyReducerEffect } from "./coordinator.js";
+
+const LOCK_RETRY_MS = 50;
+const LOCK_MAX_RETRIES = 100;
+
+function acquireLock(lockPath: string): void {
+  mkdirSync(dirname(lockPath), { recursive: true });
+  for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
+    try {
+      writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
+      return;
+    } catch (e: any) {
+      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: string): void {
+  try { unlinkSync(lockPath); } catch { /* ignore */ }
+}
+
+function isProcessRunning(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+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 abstract class ReducerBackedStore<TEntry extends { id: string }, TState, TEvent, TData> {
+  protected filePath: string | undefined;
+  protected lockPath: string | undefined;
+  private lastLoadedSignature: string | undefined;
+
+  protected nextId = 1;
+  protected entries = new Map<string, TEntry>();
+
+  private readonly config: ReducerBackedStoreConfig<TEntry, TState, TEvent, TData>;
+
+  constructor(config: ReducerBackedStoreConfig<TEntry, TState, TEvent, TData>, listIdOrPath?: string) {
+    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();
+  }
+
+  private getFileSignature(): string | undefined {
+    if (!this.filePath || !existsSync(this.filePath)) return undefined;
+    const stat = statSync(this.filePath);
+    return `${stat.mtimeMs}:${stat.size}`;
+  }
+
+  private load(force = false): void {
+    if (!this.filePath) return;
+    const signature = this.getFileSignature();
+    if (!signature) return;
+    if (!force && signature === this.lastLoadedSignature) return;
+    try {
+      const data: TData = 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 */ }
+  }
+
+  private save(): void {
+    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();
+  }
+
+  protected withLock<T>(fn: () => T): T {
+    if (!this.lockPath) return fn();
+    acquireLock(this.lockPath);
+    try {
+      this.load(true);
+      const result = fn();
+      this.save();
+      return result;
+    } finally {
+      releaseLock(this.lockPath);
+    }
+  }
+
+  protected applyReducerEvent(event: TEvent): void {
+    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.
+   */
+  protected onEffects(_effects: AnyReducerEffect[]): void { /* no-op by default */ }
+
+  /** Reload (signature-gated) and return the entry, or undefined. */
+  get(id: string): TEntry | undefined {
+    if (this.filePath) this.load();
+    return this.entries.get(id);
+  }
+
+  /** Reload (signature-gated) and return all entries sorted by numeric id. */
+  list(): TEntry[] {
+    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(): boolean {
+    if (!this.filePath || this.entries.size > 0) return false;
+    try { unlinkSync(this.filePath); } catch { /* ignore */ }
+    return true;
+  }
+}