@trevonistrevon/pi-loop 0.5.3 → 0.5.5

package/src/task-store.ts

@@ -1,127 +1,30 @@
-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 { ReducerBackedStore } from "./reducer-backed-store.js";
 import { reduceTaskState, type TaskReducerEvent, type TaskReducerState } from "./task-reducer.js";
 import type { TaskEntry, TaskStoreData } from "./task-types.js";
 
 const TASKS_DIR = join(homedir(), ".pi", "tasks");
-const LOCK_RETRY_MS = 50;
-const LOCK_MAX_RETRIES = 100;
 const MAX_TASKS = 200;
 
-function acquireLock(lockPath: string): void {
-  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 TaskStore {
-  private filePath: string | undefined;
-  private lockPath: string | undefined;
-  private lastLoadedSignature: string | undefined;
-
-  private nextId = 1;
-  private tasks = new Map<string, TaskEntry>();
-
+export class TaskStore extends ReducerBackedStore<TaskEntry, TaskReducerState, TaskReducerEvent, TaskStoreData> {
   constructor(listIdOrPath?: string) {
-    if (!listIdOrPath) return;
-    const isAbsPath = isAbsolute(listIdOrPath);
-    const filePath = isAbsPath ? listIdOrPath : join(TASKS_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: TaskStoreData = JSON.parse(readFileSync(this.filePath, "utf-8"));
-      this.nextId = data.nextId;
-      this.tasks.clear();
-      for (const task of data.tasks) {
-        this.tasks.set(task.id, task);
-      }
-      this.lastLoadedSignature = signature;
-    } catch { /* corrupt file — start fresh */ }
-  }
-
-  private save(): void {
-    if (!this.filePath) return;
-    const data: TaskStoreData = {
-      nextId: this.nextId,
-      tasks: Array.from(this.tasks.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(): TaskReducerState {
-    return {
-      nextId: this.nextId,
-      tasksById: Object.fromEntries(this.tasks.entries()),
-    };
-  }
-
-  private applyReducerEvent(event: TaskReducerEvent): void {
-    const result = reduceTaskState(this.toReducerState(), event);
-    this.nextId = result.state.nextId;
-    this.tasks = new Map(Object.entries(result.state.tasksById));
+    super(
+      {
+        baseDir: TASKS_DIR,
+        reduce: (state, event) => reduceTaskState(state, event),
+        toReducerState: (nextId, entries) => ({ nextId, tasksById: Object.fromEntries(entries.entries()) }),
+        fromReducerState: (state) => ({ nextId: state.nextId, entries: new Map(Object.entries(state.tasksById)) }),
+        serialize: (nextId, entries) => ({ nextId, tasks: Array.from(entries.values()) }),
+        deserialize: (data) => ({ nextId: data.nextId, entries: new Map(data.tasks.map((t) => [t.id, t])) }),
+      },
+      listIdOrPath,
+    );
   }
 
   create(subject: string, description: string, metadata?: Record<string, unknown>): TaskEntry {
     return this.withLock(() => {
-      if (this.tasks.size >= MAX_TASKS) {
+      if (this.entries.size >= MAX_TASKS) {
         throw new Error(`Maximum of ${MAX_TASKS} tasks reached. Delete some before creating new ones.`);
       }
       const now = Date.now();
@@ -132,23 +35,13 @@ export class TaskStore {
         entityType: "task",
         payload: { subject, description, metadata },
       });
-      return this.tasks.get(String(this.nextId - 1))!;
+      return this.entries.get(String(this.nextId - 1))!;
     });
   }
 
-  get(id: string): TaskEntry | undefined {
-    if (this.filePath) this.load();
-    return this.tasks.get(id);
-  }
-
-  list(): TaskEntry[] {
-    if (this.filePath) this.load();
-    return Array.from(this.tasks.values()).sort((a, b) => Number(a.id) - Number(b.id));
-  }
-
   start(id: string): TaskEntry | undefined {
     return this.withLock(() => {
-      const entry = this.tasks.get(id);
+      const entry = this.entries.get(id);
       if (!entry) return undefined;
       this.applyReducerEvent({
         type: "TASK_STARTED",
@@ -158,13 +51,13 @@ export class TaskStore {
         entityId: id,
         payload: { id },
       });
-      return this.tasks.get(id);
+      return this.entries.get(id);
     });
   }
 
   complete(id: string): TaskEntry | undefined {
     return this.withLock(() => {
-      const entry = this.tasks.get(id);
+      const entry = this.entries.get(id);
       if (!entry) return undefined;
       this.applyReducerEvent({
         type: "TASK_COMPLETED",
@@ -174,13 +67,13 @@ export class TaskStore {
         entityId: id,
         payload: { id },
       });
-      return this.tasks.get(id);
+      return this.entries.get(id);
     });
   }
 
   reopen(id: string): TaskEntry | undefined {
     return this.withLock(() => {
-      const entry = this.tasks.get(id);
+      const entry = this.entries.get(id);
       if (!entry) return undefined;
       this.applyReducerEvent({
         type: "TASK_REOPENED",
@@ -190,13 +83,13 @@ export class TaskStore {
         entityId: id,
         payload: { id },
       });
-      return this.tasks.get(id);
+      return this.entries.get(id);
     });
   }
 
   updateDetails(id: string, fields: { subject?: string; description?: string }): TaskEntry | undefined {
     return this.withLock(() => {
-      const entry = this.tasks.get(id);
+      const entry = this.entries.get(id);
       if (!entry) return undefined;
       if (fields.subject === undefined && fields.description === undefined) return entry;
       this.applyReducerEvent({
@@ -211,13 +104,13 @@ export class TaskStore {
           description: fields.description,
         },
       });
-      return this.tasks.get(id);
+      return this.entries.get(id);
     });
   }
 
   delete(id: string): boolean {
     return this.withLock(() => {
-      if (!this.tasks.has(id)) return false;
+      if (!this.entries.has(id)) return false;
       this.applyReducerEvent({
         type: "TASK_DELETED",
         at: Date.now(),
@@ -232,7 +125,7 @@ export class TaskStore {
 
   pendingCount(): number {
     let count = 0;
-    for (const t of this.tasks.values()) {
+    for (const t of this.entries.values()) {
       if (t.status === "pending" || t.status === "in_progress") count++;
     }
     return count;
@@ -240,7 +133,7 @@ export class TaskStore {
 
   pruneCompleted(): number {
     return this.withLock(() => {
-      const before = this.tasks.size;
+      const before = this.entries.size;
       this.applyReducerEvent({
         type: "TASKS_PRUNED",
         at: Date.now(),
@@ -248,7 +141,7 @@ export class TaskStore {
         entityType: "task",
         payload: { reason: "manual" },
       });
-      return before - this.tasks.size;
+      return before - this.entries.size;
     });
   }
 }

package/src/tools/loop-tools.ts

@@ -149,7 +149,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
       "## Task-driven workflows",
       "Do not rely on a past 'tasks:created' event to replay. If tasks already exist, bootstrap the first pass in the current turn or use a hybrid/event loop that can catch future task creation and a cron safety-net.",
       "Use autoTask only when you want the loop itself to create a task on each fire. For processing an existing task backlog, leave autoTask off and have the loop run TaskList to pick the next pending task.",
-      "Set taskBacklog: true for task-worker loops that process the existing pending queue. Task-backlog loops bootstrap against existing pending tasks and auto-delete when the queue reaches zero.",
+      "Set taskBacklog: true for backlog worker loops that process the existing pending queue. Backlog worker loops bootstrap against existing pending tasks and auto-delete when the queue reaches zero.",
       "When no tasks are pending, the loop should stop itself or skip the wake entirely — no tokens burned on empty polls.",
       "After creating a loop, tell the user the loop ID so they can cancel it with LoopDelete.",
     ],
@@ -229,10 +229,10 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
         `Loop #${entry.id} created: ${entry.prompt.slice(0, 60)}\n` +
         `Trigger: ${triggerDesc}\n` +
         `Recurring: ${entry.recurring}\n` +
-        (entry.autoTask ? "Auto-task: enabled\n" : "") +
-        (entry.taskBacklog ? "Task-backlog: enabled\n" : "") +
-        (bootstrapped ? "Bootstrap: queued initial wake for existing pending tasks\n" : "") +
-        (isTaskSystemReady() ? "" : "(task system not ready yet — autoTask may not fire until native fallback or pi-tasks becomes available)\n") +
+        (entry.autoTask ? "Auto-create task: enabled\n" : "") +
+        (entry.taskBacklog ? "Backlog worker: enabled\n" : "") +
+        (bootstrapped ? "Backlog: initial wake queued for existing pending tasks\n" : "") +
+        (isTaskSystemReady() ? "" : "Task system: not ready yet — autoTask may not fire until native fallback or pi-tasks becomes available\n") +
         `ID: ${entry.id} (use LoopDelete to cancel)`
       ));
     },
@@ -266,6 +266,7 @@ Use this before creating new loops to avoid duplicates, or to find IDs for LoopD
           line += ` next: ${formatRemaining(remaining)}`;
         }
         if (entry.autoTask) line += " [auto-task]";
+        if (entry.taskBacklog) line += " [backlog-worker]";
         lines.push(line);
       }
 

package/src/tools/monitor-tools.ts

@@ -82,10 +82,19 @@ Pass onDone with a prompt and the monitor auto-creates a one-shot loop that fire
 
       let onDoneMsg = "";
       if (params.onDone) {
+        // onDone delivery is callback-only: the loop below is delivered solely
+        // via MonitorManager.onComplete (see handleMonitorDoneLoop →
+        // monitor-ondone-runtime), so it fires exactly once by construction.
+        // The event-typed trigger is metadata, NOT a live subscription — this
+        // loop is deliberately NOT passed to triggerSystem.add(). The "event"
+        // type lets expireEventLoops() prune it if orphaned across a session
+        // and lets the widget render it as a monitor-completion wake. Do not
+        // triggerSystem.add() this loop, or the monitor:done event would fire it
+        // a second time.
         const doneTrigger: Trigger = { type: "event", source: "monitor:done", filter: JSON.stringify({ monitorId: entry.id }) };
         const doneLoop = getStore().create(doneTrigger, params.onDone, { recurring: false });
         handleMonitorDoneLoop(doneLoop, entry.id);
-        onDoneMsg = `\nonDone loop #${doneLoop.id}: fires when monitor completes — no polling needed`;
+        onDoneMsg = `\nCompletion wake loop #${doneLoop.id}: fires when the monitor completes — no polling needed`;
       }
 
       return Promise.resolve(textResult(
@@ -103,11 +112,11 @@ Pass onDone with a prompt and the monitor auto-creates a one-shot loop that fire
     parameters: Type.Object({}),
     execute() {
       const monitors = getMonitorManager().list();
-      if (monitors.length === 0) return Promise.resolve(textResult("No monitors running."));
+      if (monitors.length === 0) return Promise.resolve(textResult("No monitors."));
 
       const lines: string[] = [];
       for (const m of monitors) {
-        const icon = m.status === "running" ? ">" : m.status === "completed" ? "ok" : "!!";
+        const icon = m.status === "running" ? ">" : m.status === "completed" ? "ok" : "x";
         const age = Date.now() - m.startedAt;
         const ageStr = formatRemaining(age);
         let line = `${icon} #${m.id} [${m.status}] ${m.command.slice(0, 60)} — ${m.outputLines} lines (${ageStr})`;

package/src/tools/native-task-tools.ts

@@ -57,7 +57,7 @@ Fields:
       updateWidget();
 
       const autoLoopMsg = backlog.created && backlog.entry
-        ? `\nWorker loop #${backlog.entry.id} auto-created`
+        ? `\nBacklog worker loop #${backlog.entry.id} created`
         : "";
       return Promise.resolve(textResult(`Task #${entry.id} created: ${entry.subject}${autoLoopMsg}`));
     },
@@ -124,7 +124,7 @@ Parameters: id (required), status, subject, description`,
       const backlog = await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
       const statusMsg = status ? ` → ${status}` : "";
       const autoLoopMsg = backlog.created && backlog.entry
-        ? `\nWorker loop #${backlog.entry.id} auto-created`
+        ? `\nBacklog worker loop #${backlog.entry.id} created`
         : "";
       return Promise.resolve(textResult(`Task #${id} updated${statusMsg}${autoLoopMsg}`));
     },

package/src/trigger-system.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { atMaxFires } from "./loop-reducer.js";
 import type { CronScheduler } from "./scheduler.js";
 import type { LoopStore } from "./store.js";
 import type { LoopEntry } from "./types.js";
@@ -110,7 +111,7 @@ export class TriggerSystem {
       return;
     }
 
-    if (fresh.recurring && fresh.maxFires && (fresh.fireCount ?? 0) >= fresh.maxFires) {
+    if (fresh.recurring && atMaxFires(fresh)) {
       this.remove(fresh.id);
       this.store.delete(fresh.id);
       return;

package/src/ui/widget.ts

@@ -1,6 +1,7 @@
 import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
 import type { MonitorManager } from "../monitor-manager.js";
 import type { LoopStore } from "../store.js";
+import type { LoopEntry } from "../types.js";
 
 interface TaskSummary {
   count: number;
@@ -34,7 +35,7 @@ export class LoopWidget {
   }
 
   private computeStatus(): string | undefined {
-    const loops = this.store.list().filter(l => l.status === "active");
+    const loops = this.store.list().filter(isStatusVisibleLoop);
     const monitors = this.monitorManager.list();
     const taskSummary = this.taskSummaryProvider?.() ?? { count: 0 };
 
@@ -60,3 +61,9 @@ export class LoopWidget {
 function formatCount(count: number, noun: string): string {
   return `${count} ${noun}${count === 1 ? "" : "s"}`;
 }
+
+function isStatusVisibleLoop(loop: LoopEntry): boolean {
+  if (loop.status !== "active") return false;
+  if (loop.recurring) return true;
+  return !(loop.trigger.type === "event" && loop.trigger.source === "monitor:done");
+}

package/vitest.config.ts

@@ -0,0 +1,25 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+    include: ["test/**/*.test.ts"],
+    exclude: ["node_modules", "dist"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text-summary", "html", "json"],
+      include: ["src/**/*.ts"],
+      // Type-only modules and test helpers carry no executable logic worth gating.
+      exclude: ["src/**/*-types.ts", "src/types.ts"],
+      // Floors set just below current actuals (stmts 80%, branches 69.5%,
+      // funcs 92.5%, lines 82.9%) to catch regressions. Ratchet up as the
+      // runtime/ and tools/ suites land in Phase 4.
+      thresholds: {
+        statements: 78,
+        branches: 67,
+        functions: 90,
+        lines: 80,
+      },
+    },
+  },
+});

package/DIFFERENTIAL_REVIEW_REPORT.md

@@ -1,81 +0,0 @@
-# Differential Review Report
-
-## Update — 2026-06-02
-
-### Resolved audit finding
-- **Resolved:** recurring `event` / `hybrid` loops now clean themselves up immediately when `maxFires` is reached on the final allowed fire.
-- **Implementation:** `src/trigger-system.ts` now removes and deletes recurring event/hybrid loops as soon as `fireCount >= maxFires` after `onFire(...)` completes.
-- **Why this mattered:** the previous behavior left one stale active loop behind until the next matching event arrived, which was a real runtime cleanup bug.
-
-### Regression coverage added
-- `test/trigger-system.test.ts`
-  - recurring `event` loop is deleted immediately at final `maxFires`
-  - recurring `hybrid` loop is deleted immediately at final `maxFires`
-  - hybrid cleanup also clears scheduled cron state
-- `test/index.test.ts`
-  - extension-level `LoopCreate`/`LoopList` path confirms the loop is gone immediately after the final allowed event fire
-
-### Validation status
-- `npm run lint` ✅
-- `npm run typecheck` ✅
-- `npm run test` ✅
-- `npm run build` ✅
-- Current suite: **112 passing tests**
-
-## Scope
-Reviewed recent uncommitted changes in:
-- `src/index.ts`
-- `src/ui/widget.ts`
-- `test/index.test.ts`
-- `test/widget.test.ts`
-- `README.md`
-
-## Risk Summary
-- **Overall risk:** Medium
-- **Primary areas affected:** runtime task fallback routing, UI/widget behavior, interactive command registration
-- **Security impact:** Low direct security impact; main risks are state-management regressions and missing coverage around command behavior
-
-## Findings
-
-### 🟡 Warning
-`src/index.ts` - Native task fallback is covered for registration and file persistence, but not for interactive `/tasks` flows or loop-driven task lifecycle integration.
-
-**Why it matters:**
-The new `/tasks` command and interactive actions (`Start`, `Complete`, `Reopen`, `Delete`) are stateful and user-facing. Regressions here would not be caught by current tests. Similarly, native fallback behavior for `autoTask`, `hasPendingTasks()`, and `cleanDoneTasks()` is only indirectly covered.
-
-**Recommended follow-up:**
-Add tests for:
-- `/tasks` command registration and quick-create path
-- native `autoTask` creation path
-- `hasPendingTasks()` using native fallback
-- completed-task sweep behavior for native tasks
-
-### 🟢 Suggestion
-`src/ui/widget.ts` - Compact widget behavior is appropriately simplified and focus-oriented.
-
-**Good pattern:**
-The single-line status approach reduces noise and matches the intended UX. Showing only active/next task focus text is a good constraint.
-
-## Test Coverage Review
-
-### Covered well
-- Native tool registration when `pi-tasks` is absent/present
-- Native task persistence path (`.pi/tasks/tasks.json`)
-- Compact widget states:
-  - `none`
-  - monitor-only count
-  - loop + monitor count
-  - active task focus text
-  - next task focus text
-  - retained widget rendering after content clears
-
-### Coverage gaps
-- No tests for `/tasks` command behavior beyond registration
-- No direct tests for native `TaskUpdate` → widget focus transitions
-- No direct tests for native `cleanDoneTasks()` sweep behavior
-- No end-to-end tests for `LoopCreate(autoTask: true)` using native fallback
-
-## Review Verdict
-- **No merge-blocking issues found**
-- Safe to release after version bump and validation
-- Recommended follow-up: add native task lifecycle command/integration tests in a later pass