@trevonistrevon/pi-loop 0.5.9 → 0.6.1

package/src/runtime/task-backlog-runtime.ts

@@ -8,7 +8,13 @@ import {
   type TaskBacklogEvent,
 } from "../task-backlog-coordinator.js";
 import type { TaskStore } from "../task-store.js";
-import type { LoopEntry, Trigger } from "../types.js";
+import type { LoopDeletionTombstoneInput, LoopEntry, Trigger } from "../types.js";
+import {
+  buildLoopAutodeletedPayload,
+  buildTaskBacklogEmptyPayload,
+  type LoopAutodeletedPayload,
+  type TaskBacklogEmptyPayload,
+} from "./loop-events.js";
 
 export const AUTO_TASK_WORKER_THRESHOLD = 5;
 export const AUTO_TASK_WORKER_PROMPT = "Run TaskList, pick next pending task, mark it in_progress, implement it, run validation, complete it. If no pending tasks remain, call LoopDelete on your own loop ID.";
@@ -21,12 +27,15 @@ export interface TaskBacklogRuntimeOptions {
     maxFires?: number;
   }) => LoopEntry;
   deleteLoop: (id: string) => void;
+  recordDeletionTombstone?: (id: string, tombstone: LoopDeletionTombstoneInput) => void;
   addTrigger: (entry: LoopEntry) => void;
   removeTrigger: (id: string) => void;
   updateWidget: () => void;
   hasPendingTasks: () => Promise<number>;
   bootstrapTaskLoop: (entry: LoopEntry) => Promise<boolean>;
   triggerHasEventSource: (trigger: Trigger | string, source: string) => boolean;
+  emitLoopAutodeleted?: (payload: LoopAutodeletedPayload) => void;
+  emitTaskBacklogEmpty?: (payload: TaskBacklogEmptyPayload) => void;
   debug?: (...args: unknown[]) => void;
 }
 
@@ -44,12 +53,15 @@ export function createTaskBacklogRuntime(options: TaskBacklogRuntimeOptions): Ta
     getLoops,
     createLoop,
     deleteLoop,
+    recordDeletionTombstone,
     addTrigger,
     removeTrigger,
     updateWidget,
     hasPendingTasks,
     bootstrapTaskLoop,
     triggerHasEventSource,
+    emitLoopAutodeleted,
+    emitTaskBacklogEmpty,
     debug,
   } = options;
 
@@ -69,6 +81,14 @@ export function createTaskBacklogRuntime(options: TaskBacklogRuntimeOptions): Ta
     return getLoops().find(isAutoTaskWorkerLoop);
   }
 
+  function deleteTaskBacklogLoop(entry: LoopEntry, pendingCount: number): void {
+    debug?.(`task backlog loop #${entry.id} — no pending tasks remain, deleting`);
+    removeTrigger(entry.id);
+    recordDeletionTombstone?.(entry.id, { reason: "task_backlog_empty", pendingCount });
+    deleteLoop(entry.id);
+    emitLoopAutodeleted?.(buildLoopAutodeletedPayload(entry, pendingCount));
+  }
+
   async function cleanupTaskBacklogLoops(): Promise<number> {
     const backlogLoops = getLoops().filter(isTaskBacklogLoop);
     if (backlogLoops.length === 0) return 0;
@@ -76,11 +96,9 @@ export function createTaskBacklogRuntime(options: TaskBacklogRuntimeOptions): Ta
     const pending = await hasPendingTasks();
     if (pending < 0 || pending > 0) return 0;
 
-    for (const entry of backlogLoops) {
-      debug?.(`task backlog loop #${entry.id} — no pending tasks remain, deleting`);
-      removeTrigger(entry.id);
-      deleteLoop(entry.id);
-    }
+    const deletedLoopIds = backlogLoops.map((entry) => entry.id);
+    emitTaskBacklogEmpty?.(buildTaskBacklogEmptyPayload(deletedLoopIds));
+    for (const entry of backlogLoops) deleteTaskBacklogLoop(entry, pending);
     updateWidget();
     return backlogLoops.length;
   }
@@ -93,7 +111,7 @@ export function createTaskBacklogRuntime(options: TaskBacklogRuntimeOptions): Ta
 
     const trigger: Trigger = {
       type: "hybrid",
-      cron: "*/5 * * * *",
+      cron: "*/3 * * * *",
       event: { source: "tasks:created" },
       debounceMs: 30000,
     };

package/src/runtime/task-mutations.ts

@@ -0,0 +1,103 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { TaskStore } from "../task-store.js";
+import type { TaskEntry, TaskStatus } from "../task-types.js";
+import { emitNativeTaskEvent } from "./task-events.js";
+
+export interface TaskBacklogResult {
+  created: boolean;
+  entry?: { id: string };
+  cleaned?: number;
+}
+
+export interface TaskMutationContext {
+  pi: ExtensionAPI;
+  taskStore: TaskStore;
+  evaluateTaskBacklog: (
+    taskStore: TaskStore,
+    pendingCount: number,
+  ) => Promise<TaskBacklogResult>;
+  updateWidget: () => void;
+}
+
+export interface UpdateTaskFields {
+  id: string;
+  status?: TaskStatus;
+  subject?: string;
+  description?: string;
+}
+
+/**
+ * Single source of truth for native task mutations, shared by the TaskCreate/
+ * TaskUpdate/TaskDelete tools and the tasks:rpc:* server so both surfaces emit
+ * identical events in one canonical order: mutate → emit → widget → backlog.
+ */
+
+async function settle(ctx: TaskMutationContext): Promise<TaskBacklogResult> {
+  ctx.updateWidget();
+  return await ctx.evaluateTaskBacklog(ctx.taskStore, ctx.taskStore.pendingCount());
+}
+
+export async function createTask(
+  ctx: TaskMutationContext,
+  params: { subject: string; description: string; metadata?: Record<string, unknown> },
+): Promise<{ entry: TaskEntry; backlog: TaskBacklogResult }> {
+  const entry = ctx.taskStore.create(params.subject, params.description, params.metadata);
+  emitNativeTaskEvent(ctx.pi, "tasks:created", entry);
+  const backlog = await settle(ctx);
+  return { entry, backlog };
+}
+
+export async function updateTask(
+  ctx: TaskMutationContext,
+  params: UpdateTaskFields,
+): Promise<{ entry: TaskEntry; backlog: TaskBacklogResult } | undefined> {
+  const { id, status, subject, description } = params;
+  let entry = ctx.taskStore.get(id);
+  if (!entry) return undefined;
+
+  const previousStatus = entry.status;
+  if (status === "in_progress") {
+    entry = ctx.taskStore.start(id);
+    if (entry) emitNativeTaskEvent(ctx.pi, "tasks:started", entry, previousStatus);
+  } else if (status === "completed") {
+    entry = ctx.taskStore.complete(id);
+    if (entry) emitNativeTaskEvent(ctx.pi, "tasks:completed", entry, previousStatus);
+  } else if (status === "pending") {
+    entry = ctx.taskStore.reopen(id);
+    if (entry) emitNativeTaskEvent(ctx.pi, "tasks:reopened", entry, previousStatus);
+  }
+  if (!entry) return undefined;
+
+  if (subject !== undefined || description !== undefined) {
+    // A details edit is not a transition: its previousStatus is the status
+    // current at edit time (i.e. after any transition above), so consumers
+    // never see a fabricated second transition.
+    const statusAtEdit = entry.status;
+    entry = ctx.taskStore.updateDetails(id, { subject, description });
+    if (entry) emitNativeTaskEvent(ctx.pi, "tasks:updated", entry, statusAtEdit);
+  }
+  if (!entry) return undefined;
+
+  const backlog = await settle(ctx);
+  return { entry, backlog };
+}
+
+export async function deleteTask(
+  ctx: TaskMutationContext,
+  id: string,
+): Promise<{ entry: TaskEntry; backlog: TaskBacklogResult } | undefined> {
+  const existing = ctx.taskStore.get(id);
+  if (!existing || !ctx.taskStore.delete(id)) {
+    ctx.updateWidget();
+    return undefined;
+  }
+  emitNativeTaskEvent(ctx.pi, "tasks:deleted", existing, existing.status);
+  const backlog = await settle(ctx);
+  return { entry: existing, backlog };
+}
+
+export async function cleanTasks(ctx: TaskMutationContext): Promise<number> {
+  const pruned = ctx.taskStore.pruneCompleted();
+  await settle(ctx);
+  return pruned;
+}

package/src/runtime/task-rpc.ts

@@ -1,7 +1,17 @@
 import { randomUUID } from "node:crypto";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  type CleanReply,
+  type CreateTaskReply,
+  type PendingReply,
+  type PingReply,
+  replyChannel,
+  TASKS_RPC,
+} from "../rpc/channels.js";
+import { type RpcReply, rpcCall } from "../rpc/cross-extension-rpc.js";
 import type { TaskStore } from "../task-store.js";
 import type { LoopEntry } from "../types.js";
+import { NATIVE_TASKS_PROVIDER } from "./native-task-rpc.js";
 import { emitNativeTaskEvent } from "./task-events.js";
 
 export interface TaskRuntimeBridgeOptions {
@@ -11,6 +21,10 @@ export interface TaskRuntimeBridgeOptions {
   getNativeTaskStore: () => TaskStore | undefined;
   onNativeTaskCreated?: (taskStore: TaskStore) => void;
   onNativeTasksPruned?: (taskStore: TaskStore) => Promise<void> | void;
+  /** Called when a detection window opens. */
+  onDetectionStarted?: () => void;
+  /** Called when a detection window closes (provider found or probe timed out). */
+  onDetectionSettled?: () => void;
   debug?: (...args: unknown[]) => void;
 }
 
@@ -29,48 +43,51 @@ export function createTaskRuntimeBridge(options: TaskRuntimeBridgeOptions): Task
     getNativeTaskStore,
     onNativeTaskCreated,
     onNativeTasksPruned,
+    onDetectionStarted,
+    onDetectionSettled,
     debug,
   } = options;
+  let detectionEpoch = 0;
 
   function checkTasksVersion() {
+    // Not rpcProbe: pi-loop's own native server also answers this ping, and a
+    // first-reply-wins probe would always settle on that self-reply. Keep the
+    // listener open for the whole window and skip self-replies so a slower
+    // external provider (pi-tasks) is still detected.
+    const epoch = ++detectionEpoch;
+    onDetectionStarted?.();
+    const settleCurrentDetection = () => {
+      if (epoch !== detectionEpoch) return;
+      onDetectionSettled?.();
+    };
     const requestId = randomUUID();
     const timer = setTimeout(() => {
       unsub();
+      settleCurrentDetection();
     }, 5000);
-    const unsub = pi.events.on(`tasks:rpc:ping:reply:${requestId}`, (raw: unknown) => {
+    const unsub = pi.events.on(replyChannel(TASKS_RPC.ping, requestId), (raw: unknown) => {
+      const reply = raw as RpcReply<PingReply> | undefined;
+      if (!reply?.success || !reply.data) return;
+      if (reply.data.provider === NATIVE_TASKS_PROVIDER) return;
+      if (reply.data.version === undefined) return;
       unsub();
       clearTimeout(timer);
-      const remoteVersion = (raw as { data?: { version?: number } })?.data?.version;
-      if (remoteVersion !== undefined) setTasksAvailable(true);
+      setTasksAvailable(true);
+      settleCurrentDetection();
     });
-    pi.events.emit("tasks:rpc:ping", { requestId });
+    pi.events.emit(TASKS_RPC.ping, { requestId });
   }
 
   async function autoCreateTask(entry: LoopEntry): Promise<string | undefined> {
     if (!entry.autoTask) return undefined;
     if (isTasksAvailable()) {
       try {
-        const requestId = randomUUID();
-        const taskId = await new Promise<string | undefined>((resolve) => {
-          const timer = setTimeout(() => {
-            unsub();
-            resolve(undefined);
-          }, 5000);
-          const unsub = pi.events.on(`tasks:rpc:create:reply:${requestId}`, (raw: unknown) => {
-            unsub();
-            clearTimeout(timer);
-            const reply = raw as { success: boolean; data?: { id: string } };
-            if (reply.success && reply.data) resolve(reply.data.id);
-            else resolve(undefined);
-          });
-          pi.events.emit("tasks:rpc:create", {
-            requestId,
-            subject: entry.prompt.slice(0, 80),
-            description: `Auto-created from loop #${entry.id}`,
-            metadata: { loopId: entry.id, trigger: entry.trigger },
-          });
-        });
-        return taskId;
+        const reply = await rpcCall<CreateTaskReply>(pi.events, TASKS_RPC.create, {
+          subject: entry.prompt.slice(0, 80),
+          description: `Auto-created from loop #${entry.id}`,
+          metadata: { loopId: entry.id, trigger: entry.trigger },
+        }, 5000);
+        return reply.id;
       } catch {
         return undefined;
       }
@@ -90,22 +107,11 @@ export function createTaskRuntimeBridge(options: TaskRuntimeBridgeOptions): Task
 
   async function hasPendingTasks(): Promise<number> {
     if (isTasksAvailable()) {
+      // -1 is this bridge's "unknown" sentinel, consumed by notification-runtime;
+      // the RPC layer itself rejects on failure.
       try {
-        const requestId = randomUUID();
-        const count = await new Promise<number>((resolve) => {
-          const timer = setTimeout(() => {
-            unsub();
-            resolve(-1);
-          }, 3000);
-          const unsub = pi.events.on(`tasks:rpc:pending:reply:${requestId}`, (raw: unknown) => {
-            unsub();
-            clearTimeout(timer);
-            const reply = raw as { success: boolean; data?: { pending: number } };
-            resolve(reply.success && reply.data ? reply.data.pending : -1);
-          });
-          pi.events.emit("tasks:rpc:pending", { requestId });
-        });
-        return count;
+        const reply = await rpcCall<PendingReply>(pi.events, TASKS_RPC.pending, {}, 3000);
+        return reply.pending;
       } catch {
         return -1;
       }
@@ -117,20 +123,8 @@ export function createTaskRuntimeBridge(options: TaskRuntimeBridgeOptions): Task
   async function cleanDoneTasks(): Promise<void> {
     if (isTasksAvailable()) {
       try {
-        const requestId = randomUUID();
-        await new Promise<void>((resolve) => {
-          const timer = setTimeout(() => {
-            unsub();
-            resolve();
-          }, 3000);
-          const unsub = pi.events.on(`tasks:rpc:clean:reply:${requestId}`, () => {
-            unsub();
-            clearTimeout(timer);
-            debug?.("tasks:rpc:clean — done tasks swept");
-            resolve();
-          });
-          pi.events.emit("tasks:rpc:clean", { requestId });
-        });
+        await rpcCall<CleanReply>(pi.events, TASKS_RPC.clean, {}, 3000);
+        debug?.(`${TASKS_RPC.clean} — done tasks swept`);
       } catch {
         // timeout or error, ignore
       }

package/src/scheduler.ts

@@ -8,6 +8,9 @@ function computeNextFire(entry: LoopEntry): Date {
   if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid") {
     return cronToNextFire(entry.trigger.type === "hybrid" ? entry.trigger.cron : entry.trigger.schedule);
   }
+  if (entry.trigger.type === "dynamic") {
+    return new Date(entry.dynamic?.nextWakeAt ?? Date.now());
+  }
   return new Date(Date.now() + 60000);
 }
 
@@ -20,9 +23,19 @@ export class CronScheduler {
   ) {}
 
   start(): void {
-    for (const entry of this.store.list()) {
+    for (const storedEntry of this.store.list()) {
+      let entry = storedEntry;
       if (entry.status !== "active") continue;
-      if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid") {
+      if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid" || entry.trigger.type === "dynamic") {
+        if (entry.trigger.type === "dynamic" && entry.dynamic?.awaitingUpdate && !this.fireTimes.has(entry.id)) {
+          entry = this.store.updateDynamic(entry.id, {
+            dynamic: {
+              awaitingUpdate: false,
+              nextWakeAt: undefined,
+              lastUpdatedAt: Date.now(),
+            },
+          }) ?? entry;
+        }
         this.armTimer(entry);
       }
     }
@@ -33,7 +46,7 @@ export class CronScheduler {
   }
 
   add(entry: LoopEntry): void {
-    if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid") {
+    if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid" || entry.trigger.type === "dynamic") {
       this.armTimer(entry);
     }
   }
@@ -47,12 +60,14 @@ export class CronScheduler {
   }
 
   private armTimer(entry: LoopEntry): void {
-    const _scheduleExpr = entry.trigger.type === "hybrid" ? entry.trigger.cron : (entry.trigger as { schedule: string }).schedule;
-
     const nextFire = computeNextFire(entry);
-    const minuteField = _scheduleExpr.trim().split(/\s+/)[0];
-    const minuteStep = minuteField.startsWith("*/") ? parseInt(minuteField.slice(2), 10) || 30 : 30;
-    const jitter = computeJitter(entry.id, entry.recurring, minuteStep);
+    let jitter = 0;
+    if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid") {
+      const scheduleExpr = entry.trigger.type === "hybrid" ? entry.trigger.cron : entry.trigger.schedule;
+      const minuteField = scheduleExpr.trim().split(/\s+/)[0] ?? "";
+      const minuteStep = minuteField.startsWith("*/") ? parseInt(minuteField.slice(2), 10) || 30 : 30;
+      jitter = computeJitter(entry.id, entry.recurring, minuteStep);
+    }
     const fireTime = nextFire.getTime() + jitter;
 
     if (fireTime > entry.expiresAt) {
@@ -73,6 +88,8 @@ export class CronScheduler {
         continue;
       }
 
+      if (entry.trigger.type === "dynamic" && entry.dynamic?.awaitingUpdate) continue;
+
       if (filter && !filter(entry)) continue;
 
       if (now >= entry.expiresAt) {

package/src/store.ts

@@ -2,12 +2,15 @@ import { homedir } from "node:os";
 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";
+import type { DynamicLoopState, LoopDeletionTombstone, LoopDeletionTombstoneInput, LoopEntry, LoopStoreData, Trigger } from "./types.js";
 
 const LOOPS_DIR = join(homedir(), ".pi", "loops");
 const MAX_LOOPS = 25;
+const TOMBSTONE_TTL_MS = 10 * 60 * 1000;
 
 export class LoopStore extends ReducerBackedStore<LoopEntry, LoopReducerState, LoopReducerEvent, LoopStoreData> {
+  private tombstones = new Map<string, LoopDeletionTombstone>();
+
   constructor(listIdOrPath?: string) {
     super(
       {
@@ -22,7 +25,7 @@ export class LoopStore extends ReducerBackedStore<LoopEntry, LoopReducerState, L
     );
   }
 
-  create(trigger: Trigger, prompt: string, opts: { recurring: boolean; autoTask?: boolean; taskBacklog?: boolean; readOnly?: boolean; maxFires?: number }): LoopEntry {
+  create(trigger: Trigger, prompt: string, opts: { recurring: boolean; autoTask?: boolean; taskBacklog?: boolean; readOnly?: boolean; maxFires?: number; dynamic?: Partial<DynamicLoopState> }): LoopEntry {
     return this.withLock(() => {
       if (this.entries.size >= MAX_LOOPS) {
         throw new Error(`Maximum of ${MAX_LOOPS} loops reached. Delete some before creating new ones.`);
@@ -41,6 +44,7 @@ export class LoopStore extends ReducerBackedStore<LoopEntry, LoopReducerState, L
           taskBacklog: opts.taskBacklog,
           readOnly: opts.readOnly,
           maxFires: opts.maxFires,
+          dynamic: opts.dynamic,
         },
       });
       return this.entries.get(String(this.nextId - 1))!;
@@ -75,6 +79,22 @@ export class LoopStore extends ReducerBackedStore<LoopEntry, LoopReducerState, L
         entityId: id,
         payload: { id },
       });
+      if (entry.trigger.type === "dynamic" && entry.dynamic?.awaitingUpdate) {
+        this.applyReducerEvent({
+          type: "LOOP_DYNAMIC_UPDATED",
+          at: Date.now(),
+          source: "tool",
+          entityType: "loop",
+          entityId: id,
+          payload: {
+            id,
+            dynamic: {
+              awaitingUpdate: false,
+              lastUpdatedAt: Date.now(),
+            },
+          },
+        });
+      }
       return this.entries.get(id);
     });
   }
@@ -119,6 +139,43 @@ export class LoopStore extends ReducerBackedStore<LoopEntry, LoopReducerState, L
     });
   }
 
+  updateDynamic(id: string, fields: { prompt?: string; dynamic: Partial<DynamicLoopState> }): LoopEntry | undefined {
+    return this.withLock(() => {
+      if (!this.entries.has(id)) return undefined;
+      this.applyReducerEvent({
+        type: "LOOP_DYNAMIC_UPDATED",
+        at: Date.now(),
+        source: "tool",
+        entityType: "loop",
+        entityId: id,
+        payload: { id, prompt: fields.prompt, dynamic: fields.dynamic },
+      });
+      return this.entries.get(id);
+    });
+  }
+
+  getDeletionTombstone(id: string): LoopDeletionTombstone | undefined {
+    const tombstone = this.tombstones.get(id);
+    if (!tombstone) return undefined;
+    if (Date.now() - tombstone.deletedAt <= TOMBSTONE_TTL_MS) return tombstone;
+    this.tombstones.delete(id);
+    return undefined;
+  }
+
+  recordDeletionTombstone(id: string, input: LoopDeletionTombstoneInput): LoopDeletionTombstone | undefined {
+    const entry = this.entries.get(id);
+    if (!entry) return undefined;
+    const tombstone: LoopDeletionTombstone = {
+      id,
+      reason: input.reason,
+      pendingCount: input.pendingCount,
+      deletedAt: Date.now(),
+      prompt: entry.prompt,
+    };
+    this.tombstones.set(id, tombstone);
+    return tombstone;
+  }
+
   delete(id: string): boolean {
     return this.withLock(() => {
       if (!this.entries.has(id)) return false;