@trevonistrevon/pi-loop 0.5.0 → 0.5.1

package/src/runtime/monitor-ondone-runtime.ts

@@ -0,0 +1,75 @@
+import {
+  createCoordinator,
+  type ReducerEffect,
+  type ReducerEvent,
+  type ReducerHandler,
+} from "../coordinator.js";
+import {
+  type MonitorCompletionEvent,
+  reduceMonitorCompletionEvent,
+} from "../monitor-completion-coordinator.js";
+import type { MonitorManager } from "../monitor-manager.js";
+import type { LoopEntry } from "../types.js";
+
+export interface MonitorOnDoneRuntimeOptions {
+  monitorManager: MonitorManager;
+  getLoop: (id: string) => LoopEntry | undefined;
+  deleteLoop: (id: string) => void;
+  onLoopFire: (entry: LoopEntry) => void;
+  debug?: (...args: unknown[]) => void;
+}
+
+export interface MonitorOnDoneRuntime {
+  register(doneLoop: LoopEntry, monitorId: string): void;
+}
+
+export function createMonitorOnDoneRuntime(options: MonitorOnDoneRuntimeOptions): MonitorOnDoneRuntime {
+  const { monitorManager, getLoop, deleteLoop, onLoopFire, debug } = options;
+
+  const monitorCompletionReducerHandler: ReducerHandler = (incoming: ReducerEvent) => {
+    if (incoming.type !== "MONITOR_ONDONE_TRIGGERED") return [];
+    return reduceMonitorCompletionEvent(incoming as MonitorCompletionEvent);
+  };
+
+  const monitorCompletionCoordinator = createCoordinator({
+    reducers: [monitorCompletionReducerHandler],
+    effectHandlers: {
+      DELIVER_MONITOR_ONDONE_WAKE: (effect: ReducerEffect) => {
+        const { loopId, monitorId } = effect.payload as { loopId: string; monitorId: string };
+        const current = getLoop(loopId);
+        if (!current) return;
+        debug?.(`onDone loop #${loopId} — monitor #${monitorId} completed, delivering through coordinator`);
+        onLoopFire(current);
+        deleteLoop(loopId);
+      },
+    },
+  });
+
+  function register(doneLoop: LoopEntry, monitorId: string): void {
+    const deliver = () => {
+      void monitorCompletionCoordinator.dispatch({
+        type: "MONITOR_ONDONE_TRIGGERED",
+        at: Date.now(),
+        source: "monitor",
+        entityType: "monitor",
+        entityId: monitorId,
+        payload: { loopId: doneLoop.id, monitorId },
+      });
+    };
+
+    const registered = monitorManager.onComplete(monitorId, deliver);
+    if (registered) return;
+
+    const monitor = monitorManager.get(monitorId);
+    if (monitor && monitor.status !== "running") {
+      if (monitor.status === "completed") {
+        deliver();
+        return;
+      }
+      debug?.(`onDone loop #${doneLoop.id} — monitor #${monitorId} already ${monitor.status}, expiring`);
+      deleteLoop(doneLoop.id);
+    }
+  }
+
+  return { register };
+}

package/src/runtime/notification-runtime.ts

@@ -0,0 +1,212 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  createCoordinator,
+  type ReducerEffect,
+  type ReducerEvent,
+  type ReducerHandler,
+} from "../coordinator.js";
+import {
+  type NotificationReducerEvent,
+  type NotificationReducerState,
+  type ReducerNotification,
+  reduceNotificationState,
+} from "../notification-reducer.js";
+import type { Trigger } from "../types.js";
+
+export interface LoopFireEvent {
+  loopId: string;
+  prompt: string;
+  trigger: Trigger | string;
+  timestamp: number;
+  readOnly?: boolean;
+  recurring?: boolean;
+  autoTask?: boolean;
+}
+
+export interface PendingNotification extends LoopFireEvent {
+  key: string;
+  message: string;
+}
+
+export interface NotificationRuntimeOptions {
+  pi: ExtensionAPI;
+  hasPendingTasks: () => Promise<number>;
+  cleanDoneTasks: () => Promise<void>;
+  getHasPendingMessages: () => boolean;
+  debug?: (...args: unknown[]) => void;
+}
+
+export interface NotificationRuntime {
+  syncRuntimeState(options?: { agentRunning?: boolean; hasPendingMessages?: boolean }): void;
+  queueOrDeliverNotification(data: LoopFireEvent): Promise<void>;
+  flushPendingNotifications(options?: { ignorePendingMessages?: boolean }): Promise<void>;
+  clear(reason: "session_shutdown" | "session_switch"): void;
+}
+
+export function createNotificationRuntime(options: NotificationRuntimeOptions): NotificationRuntime {
+  const { pi, hasPendingTasks, cleanDoneTasks, getHasPendingMessages, debug } = options;
+
+  let notificationState: NotificationReducerState = {
+    notificationsByKey: {},
+    agentRunning: false,
+    hasPendingMessages: false,
+  };
+  let flushPromise: Promise<void> | undefined;
+  let notificationCoordinatorDelivered = false;
+  let notificationCoordinatorDeliveredSuccessfully = false;
+
+  const notificationReducerHandler: ReducerHandler = (incoming: ReducerEvent) => {
+    const result = reduceNotificationState(notificationState, incoming as NotificationReducerEvent);
+    notificationState = result.state;
+    return result.effects;
+  };
+
+  const notificationCoordinator = createCoordinator({
+    reducers: [notificationReducerHandler],
+    effectHandlers: {
+      REQUEST_NOTIFICATION_FLUSH: () => {},
+      DELIVER_NOTIFICATION: async (effect: ReducerEffect) => {
+        notificationCoordinatorDelivered = true;
+        notificationCoordinatorDeliveredSuccessfully = await deliverNotification(
+          (effect.payload as { notification: ReducerNotification }).notification,
+        );
+      },
+    },
+  });
+
+  function applyNotificationEvent(event: NotificationReducerEvent) {
+    const result = reduceNotificationState(notificationState, event);
+    notificationState = result.state;
+    return result;
+  }
+
+  function syncRuntimeState(options?: { agentRunning?: boolean; hasPendingMessages?: boolean }) {
+    applyNotificationEvent({
+      type: "NOTIFICATION_RUNTIME_UPDATED",
+      at: Date.now(),
+      source: "system",
+      entityType: "notification",
+      payload: {
+        agentRunning: options?.agentRunning ?? notificationState.agentRunning,
+        hasPendingMessages: options?.hasPendingMessages ?? getHasPendingMessages(),
+      },
+    });
+  }
+
+  function buildLoopFireMessage(data: LoopFireEvent): string {
+    const triggerInfo = typeof data.trigger === "string"
+      ? data.trigger
+      : data.trigger?.type === "cron"
+        ? `schedule: ${data.trigger.schedule}`
+        : data.trigger?.type === "event"
+          ? `event: ${data.trigger.source}`
+          : "hybrid";
+
+    const loopId = data.loopId || "?";
+    const prompt = data.prompt || "loop fired";
+    const constraint = data.readOnly
+      ? "\n\nREAD-ONLY MODE — use only read tools (Read, TaskList, LoopList, MonitorList, etc.). No file writes, shell execution, or destructive changes."
+      : "";
+
+    return [
+      `[pi-loop] Loop #${loopId} fired (${triggerInfo}).${constraint}`,
+      prompt,
+    ].join("\n");
+  }
+
+  function buildPendingNotification(data: LoopFireEvent): PendingNotification {
+    const key = data.recurring ? `loop:${data.loopId}` : `loop:${data.loopId}:${data.timestamp}`;
+    return {
+      ...data,
+      key,
+      message: buildLoopFireMessage(data),
+    };
+  }
+
+  async function deliverNotification(notification: ReducerNotification): Promise<boolean> {
+    if (notification.autoTask) {
+      const pending = await hasPendingTasks();
+      if (pending === 0) {
+        debug?.(`loop:fire #${notification.loopId} — no pending tasks at delivery time, dropping wake`);
+        await cleanDoneTasks();
+        return false;
+      }
+    }
+
+    syncRuntimeState({ agentRunning: true });
+    pi.sendMessage({
+      customType: "pi-loop",
+      content: notification.message,
+      display: false,
+      details: {
+        loopId: notification.loopId,
+        trigger: notification.trigger,
+        recurring: notification.recurring,
+        readOnly: notification.readOnly,
+        autoTask: notification.autoTask,
+        timestamp: notification.timestamp,
+      },
+    }, {
+      deliverAs: "steer",
+      triggerTurn: true,
+    });
+    return true;
+  }
+
+  async function flushPendingNotifications(options?: { ignorePendingMessages?: boolean }): Promise<void> {
+    if (flushPromise) return flushPromise;
+
+    flushPromise = (async () => {
+      syncRuntimeState({ hasPendingMessages: getHasPendingMessages() });
+
+      while (true) {
+        notificationCoordinatorDelivered = false;
+        notificationCoordinatorDeliveredSuccessfully = false;
+        await notificationCoordinator.dispatch({
+          type: "NOTIFICATION_FLUSH_REQUESTED",
+          at: Date.now(),
+          source: "system",
+          entityType: "notification",
+          payload: { ignorePendingMessages: options?.ignorePendingMessages },
+        });
+        if (!notificationCoordinatorDelivered) return;
+        if (notificationCoordinatorDeliveredSuccessfully) return;
+      }
+    })().finally(() => {
+      flushPromise = undefined;
+    });
+
+    return flushPromise;
+  }
+
+  async function queueOrDeliverNotification(data: LoopFireEvent): Promise<void> {
+    const notification = buildPendingNotification(data);
+    applyNotificationEvent({
+      type: "NOTIFICATION_QUEUED",
+      at: notification.timestamp,
+      source: "system",
+      entityType: "notification",
+      entityId: notification.key,
+      payload: { notification },
+    });
+    await flushPendingNotifications();
+  }
+
+  function clear(reason: "session_shutdown" | "session_switch") {
+    syncRuntimeState({ agentRunning: false, hasPendingMessages: false });
+    applyNotificationEvent({
+      type: "NOTIFICATION_CLEARED",
+      at: Date.now(),
+      source: "session",
+      entityType: "notification",
+      payload: { reason },
+    });
+  }
+
+  return {
+    syncRuntimeState,
+    queueOrDeliverNotification,
+    flushPendingNotifications,
+    clear,
+  };
+}

package/src/runtime/scope.ts

@@ -0,0 +1,37 @@
+import { join, resolve } from "node:path";
+
+export type LoopScope = "memory" | "session" | "project";
+
+export interface ScopeOptions {
+  piLoopEnv?: string;
+  loopScope: LoopScope;
+  cwd?: string;
+}
+
+export function resolveLoopStorePath(options: ScopeOptions, sessionId?: string): string | undefined {
+  const cwd = options.cwd ?? process.cwd();
+  const { piLoopEnv, loopScope } = options;
+
+  if (piLoopEnv === "off") return undefined;
+  if (piLoopEnv?.startsWith("/")) return piLoopEnv;
+  if (piLoopEnv?.startsWith(".")) return resolve(piLoopEnv);
+  if (piLoopEnv) return piLoopEnv;
+  if (loopScope === "memory") return undefined;
+  if (loopScope === "session" && sessionId) {
+    return join(cwd, ".pi", "loops", `loops-${sessionId}.json`);
+  }
+  if (loopScope === "session") return undefined;
+  return join(cwd, ".pi", "loops", "loops.json");
+}
+
+export function resolveTaskStorePath(options: ScopeOptions, sessionId?: string): string | undefined {
+  const cwd = options.cwd ?? process.cwd();
+  const { loopScope } = options;
+
+  if (loopScope === "memory") return undefined;
+  if (loopScope === "session" && sessionId) {
+    return join(cwd, ".pi", "tasks", `tasks-${sessionId}.json`);
+  }
+  if (loopScope === "session") return undefined;
+  return join(cwd, ".pi", "tasks", "tasks.json");
+}

package/src/runtime/session-runtime.ts

@@ -0,0 +1,168 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { LoopStore } from "../store.js";
+import type { NotificationRuntime } from "./notification-runtime.js";
+import type { LoopScope } from "./scope.js";
+
+export interface SessionSwitchEvent {
+  reason?: string;
+}
+
+export interface SessionRuntimeOptions {
+  pi: ExtensionAPI;
+  getLoopScope: () => LoopScope;
+  getPiLoopEnv: () => string | undefined;
+  recreateSessionStore: (sessionId: string) => void;
+  clearAllLoops: () => void;
+  getStore: () => LoopStore;
+  getScheduler: () => { nextFire(id: string): number | undefined; pump(now: number, filter?: (entry: { id: string }) => boolean): void };
+  getTriggerSystem: () => { start(): void; stop(): void };
+  setLatestCtx: (ctx: ExtensionContext) => void;
+  setSessionId: (sessionId: string | undefined) => void;
+  widget: { setUICtx(ui: ExtensionContext["ui"]): void; update(): void };
+  notificationRuntime: NotificationRuntime;
+  flushPendingNotifications: (options?: { ignorePendingMessages?: boolean }) => Promise<void>;
+  cleanupTaskBacklogLoops: () => Promise<number>;
+  hasPendingTasks: () => Promise<number>;
+  cleanDoneTasks: () => Promise<void>;
+}
+
+export function registerSessionRuntimeHooks(options: SessionRuntimeOptions): void {
+  const {
+    pi,
+    getLoopScope,
+    getPiLoopEnv,
+    recreateSessionStore,
+    clearAllLoops,
+    getStore,
+    getScheduler,
+    getTriggerSystem,
+    setLatestCtx,
+    setSessionId,
+    widget,
+    notificationRuntime,
+    flushPendingNotifications,
+    cleanupTaskBacklogLoops,
+    hasPendingTasks,
+    cleanDoneTasks,
+  } = options;
+
+  let storeUpgraded = false;
+  let persistedShown = false;
+
+  function upgradeStoreIfNeeded(ctx: ExtensionContext) {
+    if (storeUpgraded) return;
+    if (getLoopScope() === "session" && !getPiLoopEnv()) {
+      recreateSessionStore(ctx.sessionManager.getSessionId());
+    }
+    storeUpgraded = true;
+  }
+
+  function showPersistedLoops(_isResume = false) {
+    if (persistedShown) return;
+    persistedShown = true;
+    const sessionStartedAt = Date.now();
+    const loops = getStore().list();
+    if (loops.length > 0) {
+      getStore().clearExpired();
+      getStore().expireEventLoops(sessionStartedAt);
+      getTriggerSystem().start();
+      widget.update();
+    }
+  }
+
+  async function pumpLoops(): Promise<void> {
+    const pendingTasks = new Map<string, boolean>();
+    for (const entry of getStore().list()) {
+      if (entry.status !== "active") continue;
+      if (!entry.autoTask) continue;
+      if (entry.trigger.type !== "cron" && entry.trigger.type !== "hybrid") continue;
+      const nextFire = getScheduler().nextFire(entry.id);
+      if (!nextFire || Date.now() < nextFire) continue;
+      const pending = await hasPendingTasks();
+      if (pending <= 0) pendingTasks.set(entry.id, true);
+    }
+    getScheduler().pump(Date.now(), (entry) => !pendingTasks.has(entry.id));
+  }
+
+  pi.on("turn_start", async (_event, ctx) => {
+    setLatestCtx(ctx);
+    setSessionId(ctx.sessionManager.getSessionId());
+    widget.setUICtx(ctx.ui);
+    upgradeStoreIfNeeded(ctx);
+    widget.update();
+    await pumpLoops();
+  });
+
+  pi.on("before_agent_start", async (_event, ctx) => {
+    setLatestCtx(ctx);
+    widget.setUICtx(ctx.ui);
+    upgradeStoreIfNeeded(ctx);
+    showPersistedLoops();
+    widget.update();
+  });
+
+  pi.on("agent_start", async (_event, ctx) => {
+    notificationRuntime.syncRuntimeState({
+      agentRunning: true,
+      hasPendingMessages: ctx.hasPendingMessages(),
+    });
+    setLatestCtx(ctx);
+    widget.setUICtx(ctx.ui);
+  });
+
+  pi.on("agent_end", async (_event, ctx) => {
+    setLatestCtx(ctx);
+    widget.setUICtx(ctx.ui);
+    notificationRuntime.syncRuntimeState({
+      agentRunning: false,
+      hasPendingMessages: ctx.hasPendingMessages(),
+    });
+    await flushPendingNotifications({ ignorePendingMessages: true });
+    await cleanupTaskBacklogLoops();
+    await pumpLoops();
+  });
+
+  pi.on("session_shutdown", async () => {
+    notificationRuntime.clear("session_shutdown");
+  });
+
+  pi.on("session_switch" as never, async (event: SessionSwitchEvent, ctx: ExtensionContext) => {
+    setLatestCtx(ctx);
+    widget.setUICtx(ctx.ui);
+    getTriggerSystem().stop();
+    notificationRuntime.clear("session_switch");
+    setSessionId(undefined);
+
+    const isResume = event?.reason === "resume";
+    storeUpgraded = false;
+    persistedShown = false;
+
+    if (!isResume && getLoopScope() === "memory") {
+      clearAllLoops();
+    }
+
+    upgradeStoreIfNeeded(ctx);
+    showPersistedLoops(isResume);
+    widget.update();
+  });
+
+  pi.on("tool_execution_end", async (event: unknown, ctx: ExtensionContext) => {
+    setLatestCtx(ctx);
+    widget.setUICtx(ctx.ui);
+
+    const typed = event as {
+      toolName?: string;
+      isError?: boolean;
+      args?: { command?: string };
+      input?: { command?: string };
+    };
+
+    if (typed.toolName !== "bash" || typed.isError) return;
+
+    const command = typed.args?.command ?? typed.input?.command;
+    if (typeof command !== "string") return;
+    if (!/^\s*git\s+commit\b/i.test(command)) return;
+
+    await cleanDoneTasks();
+  });
+}

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

@@ -0,0 +1,163 @@
+import {
+  createCoordinator,
+  type ReducerEvent,
+  type ReducerHandler,
+} from "../coordinator.js";
+import {
+  reduceTaskBacklogEvent,
+  type TaskBacklogEvent,
+} from "../task-backlog-coordinator.js";
+import type { TaskStore } from "../task-store.js";
+import type { LoopEntry, Trigger } from "../types.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.";
+
+export interface TaskBacklogRuntimeOptions {
+  getLoops: () => LoopEntry[];
+  createLoop: (trigger: Trigger, prompt: string, options: {
+    recurring: boolean;
+    taskBacklog?: boolean;
+    maxFires?: number;
+  }) => LoopEntry;
+  deleteLoop: (id: string) => 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;
+  debug?: (...args: unknown[]) => void;
+}
+
+export interface TaskBacklogRuntime {
+  cleanupTaskBacklogLoops(): Promise<number>;
+  ensureAutoTaskWorkerLoop(taskStore: TaskStore): Promise<{ entry?: LoopEntry; created: boolean }>;
+  evaluateTaskBacklog(taskStore?: TaskStore, pendingCount?: number): Promise<{ entry?: LoopEntry; created: boolean; cleaned: number }>;
+  isAutoTaskWorkerLoop(entry: LoopEntry): boolean;
+  isTaskBacklogLoop(entry: LoopEntry): boolean;
+  findAutoTaskWorkerLoop(): LoopEntry | undefined;
+}
+
+export function createTaskBacklogRuntime(options: TaskBacklogRuntimeOptions): TaskBacklogRuntime {
+  const {
+    getLoops,
+    createLoop,
+    deleteLoop,
+    addTrigger,
+    removeTrigger,
+    updateWidget,
+    hasPendingTasks,
+    bootstrapTaskLoop,
+    triggerHasEventSource,
+    debug,
+  } = options;
+
+  function isAutoTaskWorkerLoop(entry: LoopEntry): boolean {
+    return entry.status === "active"
+      && entry.prompt === AUTO_TASK_WORKER_PROMPT
+      && triggerHasEventSource(entry.trigger, "tasks:created");
+  }
+
+  function isTaskBacklogLoop(entry: LoopEntry): boolean {
+    return entry.status === "active"
+      && triggerHasEventSource(entry.trigger, "tasks:created")
+      && (entry.taskBacklog === true || isAutoTaskWorkerLoop(entry));
+  }
+
+  function findAutoTaskWorkerLoop(): LoopEntry | undefined {
+    return getLoops().find(isAutoTaskWorkerLoop);
+  }
+
+  async function cleanupTaskBacklogLoops(): Promise<number> {
+    const backlogLoops = getLoops().filter(isTaskBacklogLoop);
+    if (backlogLoops.length === 0) return 0;
+
+    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);
+    }
+    updateWidget();
+    return backlogLoops.length;
+  }
+
+  async function ensureAutoTaskWorkerLoop(taskStore: TaskStore): Promise<{ entry?: LoopEntry; created: boolean }> {
+    if (taskStore.pendingCount() < AUTO_TASK_WORKER_THRESHOLD) return { created: false };
+
+    const existing = findAutoTaskWorkerLoop();
+    if (existing) return { entry: existing, created: false };
+
+    const trigger: Trigger = {
+      type: "hybrid",
+      cron: "*/5 * * * *",
+      event: { source: "tasks:created" },
+      debounceMs: 30000,
+    };
+    const entry = createLoop(trigger, AUTO_TASK_WORKER_PROMPT, {
+      recurring: true,
+      taskBacklog: true,
+      maxFires: 30,
+    });
+    addTrigger(entry);
+    await bootstrapTaskLoop(entry);
+    updateWidget();
+    return { entry, created: true };
+  }
+
+  let taskBacklogCoordinatorStore: TaskStore | undefined;
+  let taskBacklogCoordinatorWorker: { entry?: LoopEntry; created: boolean } = { created: false };
+  let taskBacklogCoordinatorCleanupCount = 0;
+
+  const taskBacklogReducerHandler: ReducerHandler = (incoming: ReducerEvent) => {
+    if (incoming.type !== "TASK_BACKLOG_EVALUATED") return [];
+    return reduceTaskBacklogEvent(incoming as TaskBacklogEvent);
+  };
+
+  const taskBacklogCoordinator = createCoordinator({
+    reducers: [taskBacklogReducerHandler],
+    effectHandlers: {
+      ENSURE_AUTO_TASK_WORKER: async () => {
+        if (!taskBacklogCoordinatorStore) return;
+        taskBacklogCoordinatorWorker = await ensureAutoTaskWorkerLoop(taskBacklogCoordinatorStore);
+      },
+      CLEANUP_TASK_BACKLOG_LOOPS: async () => {
+        taskBacklogCoordinatorCleanupCount = await cleanupTaskBacklogLoops();
+      },
+    },
+  });
+
+  async function evaluateTaskBacklog(taskStore?: TaskStore, pendingCount?: number): Promise<{ entry?: LoopEntry; created: boolean; cleaned: number }> {
+    const resolvedPending = pendingCount ?? (taskStore ? taskStore.pendingCount() : await hasPendingTasks());
+    taskBacklogCoordinatorStore = taskStore;
+    taskBacklogCoordinatorWorker = { created: false };
+    taskBacklogCoordinatorCleanupCount = 0;
+
+    await taskBacklogCoordinator.dispatch({
+      type: "TASK_BACKLOG_EVALUATED",
+      at: Date.now(),
+      source: "system",
+      entityType: "task",
+      payload: { pendingCount: resolvedPending, threshold: AUTO_TASK_WORKER_THRESHOLD },
+    });
+
+    taskBacklogCoordinatorStore = undefined;
+    return {
+      entry: taskBacklogCoordinatorWorker.entry,
+      created: taskBacklogCoordinatorWorker.created,
+      cleaned: taskBacklogCoordinatorCleanupCount,
+    };
+  }
+
+  return {
+    cleanupTaskBacklogLoops,
+    ensureAutoTaskWorkerLoop,
+    evaluateTaskBacklog,
+    isAutoTaskWorkerLoop,
+    isTaskBacklogLoop,
+    findAutoTaskWorkerLoop,
+  };
+}