@trevonistrevon/pi-loop 0.5.4 → 0.5.5

package/src/store.ts

@@ -1,128 +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 { type LoopReducerEvent, type LoopReducerState, reduceLoopState } from "./loop-reducer.js";
+import { ReducerBackedStore } from "./reducer-backed-store.js";
 import type { LoopEntry, LoopStoreData, Trigger } from "./types.js";
 
 const LOOPS_DIR = join(homedir(), ".pi", "loops");
-const LOCK_RETRY_MS = 50;
-const LOCK_MAX_RETRIES = 100;
 const MAX_LOOPS = 25;
 
-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 LoopStore {
-  private filePath: string | undefined;
-  private lockPath: string | undefined;
-  private lastLoadedSignature: string | undefined;
-
-  private nextId = 1;
-  private loops = new Map<string, LoopEntry>();
-
+export class LoopStore extends ReducerBackedStore<LoopEntry, LoopReducerState, LoopReducerEvent, LoopStoreData> {
   constructor(listIdOrPath?: string) {
-    if (!listIdOrPath) return;
-    const isAbsPath = isAbsolute(listIdOrPath);
-    const filePath = isAbsPath ? listIdOrPath : join(LOOPS_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: LoopStoreData = JSON.parse(readFileSync(this.filePath, "utf-8"));
-      this.nextId = data.nextId;
-      this.loops.clear();
-      for (const loop of data.loops) {
-        this.loops.set(loop.id, loop);
-      }
-      this.lastLoadedSignature = signature;
-    } catch { /* corrupt file — start fresh */ }
-  }
-
-  private save(): void {
-    if (!this.filePath) return;
-    const data: LoopStoreData = {
-      nextId: this.nextId,
-      loops: Array.from(this.loops.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(): LoopReducerState {
-    return {
-      nextId: this.nextId,
-      loopsById: Object.fromEntries(this.loops.entries()),
-    };
-  }
-
-  private applyReducerEvent(event: LoopReducerEvent): void {
-    const result = reduceLoopState(this.toReducerState(), event);
-    this.nextId = result.state.nextId;
-    this.loops = new Map(Object.entries(result.state.loopsById));
+    super(
+      {
+        baseDir: LOOPS_DIR,
+        reduce: (state, event) => reduceLoopState(state, event),
+        toReducerState: (nextId, entries) => ({ nextId, loopsById: Object.fromEntries(entries.entries()) }),
+        fromReducerState: (state) => ({ nextId: state.nextId, entries: new Map(Object.entries(state.loopsById)) }),
+        serialize: (nextId, entries) => ({ nextId, loops: Array.from(entries.values()) }),
+        deserialize: (data) => ({ nextId: data.nextId, entries: new Map(data.loops.map((l) => [l.id, l])) }),
+      },
+      listIdOrPath,
+    );
   }
 
   create(trigger: Trigger, prompt: string, opts: { recurring: boolean; autoTask?: boolean; taskBacklog?: boolean; readOnly?: boolean; maxFires?: number }): LoopEntry {
     return this.withLock(() => {
-      if (this.loops.size >= MAX_LOOPS) {
+      if (this.entries.size >= MAX_LOOPS) {
         throw new Error(`Maximum of ${MAX_LOOPS} loops reached. Delete some before creating new ones.`);
       }
       const now = Date.now();
@@ -141,23 +43,13 @@ export class LoopStore {
           maxFires: opts.maxFires,
         },
       });
-      return this.loops.get(String(this.nextId - 1))!;
+      return this.entries.get(String(this.nextId - 1))!;
     });
   }
 
-  get(id: string): LoopEntry | undefined {
-    if (this.filePath) this.load();
-    return this.loops.get(id);
-  }
-
-  list(): LoopEntry[] {
-    if (this.filePath) this.load();
-    return Array.from(this.loops.values()).sort((a, b) => Number(a.id) - Number(b.id));
-  }
-
   pause(id: string): LoopEntry | undefined {
     return this.withLock(() => {
-      const entry = this.loops.get(id);
+      const entry = this.entries.get(id);
       if (!entry) return undefined;
       this.applyReducerEvent({
         type: "LOOP_PAUSED",
@@ -167,13 +59,13 @@ export class LoopStore {
         entityId: id,
         payload: { id },
       });
-      return this.loops.get(id);
+      return this.entries.get(id);
     });
   }
 
   resume(id: string): LoopEntry | undefined {
     return this.withLock(() => {
-      const entry = this.loops.get(id);
+      const entry = this.entries.get(id);
       if (!entry) return undefined;
       this.applyReducerEvent({
         type: "LOOP_RESUMED",
@@ -183,13 +75,13 @@ export class LoopStore {
         entityId: id,
         payload: { id },
       });
-      return this.loops.get(id);
+      return this.entries.get(id);
     });
   }
 
   fire(id: string): LoopEntry | undefined {
     return this.withLock(() => {
-      const entry = this.loops.get(id);
+      const entry = this.entries.get(id);
       if (!entry) return undefined;
       this.applyReducerEvent({
         type: "LOOP_FIRED",
@@ -199,13 +91,13 @@ export class LoopStore {
         entityId: id,
         payload: { id },
       });
-      return this.loops.get(id);
+      return this.entries.get(id);
     });
   }
 
   updateMetadata(id: string, fields: { trigger?: Trigger; prompt?: string }): { entry: LoopEntry | undefined; changedFields: string[] } {
     return this.withLock(() => {
-      const current = this.loops.get(id);
+      const current = this.entries.get(id);
       if (!current) return { entry: undefined, changedFields: [] };
 
       const changedFields: string[] = [];
@@ -223,13 +115,13 @@ export class LoopStore {
         current.updatedAt = now;
       }
 
-      return { entry: this.loops.get(id), changedFields };
+      return { entry: this.entries.get(id), changedFields };
     });
   }
 
   delete(id: string): boolean {
     return this.withLock(() => {
-      if (!this.loops.has(id)) return false;
+      if (!this.entries.has(id)) return false;
       this.applyReducerEvent({
         type: "LOOP_DELETED",
         at: Date.now(),
@@ -246,7 +138,7 @@ export class LoopStore {
     return this.withLock(() => {
       const now = Date.now();
       let count = 0;
-      for (const [id, entry] of [...this.loops.entries()]) {
+      for (const [id, entry] of [...this.entries.entries()]) {
         if (now < entry.expiresAt) continue;
         this.applyReducerEvent({
           type: "LOOP_EXPIRED",
@@ -265,7 +157,7 @@ export class LoopStore {
   expireEventLoops(sessionStartedAt: number): number {
     return this.withLock(() => {
       let count = 0;
-      for (const [id, entry] of [...this.loops.entries()]) {
+      for (const [id, entry] of [...this.entries.entries()]) {
         if (entry.status !== "active") continue;
         if (entry.trigger.type !== "event" && entry.trigger.type !== "hybrid") continue;
         if (entry.createdAt >= sessionStartedAt) continue;
@@ -285,7 +177,7 @@ export class LoopStore {
 
   clearAll(): number {
     return this.withLock(() => {
-      const ids = [...this.loops.keys()];
+      const ids = [...this.entries.keys()];
       for (const id of ids) {
         this.applyReducerEvent({
           type: "LOOP_DELETED",
@@ -299,10 +191,4 @@ export class LoopStore {
       return ids.length;
     });
   }
-
-  deleteFileIfEmpty(): boolean {
-    if (!this.filePath || this.loops.size > 0) return false;
-    try { unlinkSync(this.filePath); } catch { /* ignore */ }
-    return true;
-  }
 }

package/src/task-reducer.ts

@@ -136,6 +136,9 @@ export function reduceTaskState(state: TaskReducerState, event: TaskReducerEvent
   if (event.type === "TASK_REOPENED") {
     task.status = "pending";
     task.updatedAt = event.at;
+    // `completedAt` is intentionally retained: it records the most recent
+    // completion, not "is currently complete" (use `status` for that). A
+    // reopened task keeps the timestamp of when it was last completed.
   }
 
   if (event.type === "TASK_UPDATED") {

package/src/task-store.ts

@@ -1,128 +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 {
-  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 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();
@@ -133,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",
@@ -159,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",
@@ -175,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",
@@ -191,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({
@@ -212,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(),
@@ -233,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;
@@ -241,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(),
@@ -249,7 +141,7 @@ export class TaskStore {
         entityType: "task",
         payload: { reason: "manual" },
       });
-      return before - this.tasks.size;
+      return before - this.entries.size;
     });
   }
 }

package/src/tools/monitor-tools.ts

@@ -82,6 +82,15 @@ 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);

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/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