@trevonistrevon/pi-loop 0.5.9 → 0.6.1

package/dist/rpc/cross-extension-rpc.js

@@ -0,0 +1,117 @@
+// VENDORED MODULE — canonical copy shared verbatim by pi-loop and pi-orca.
+// If you edit this file, copy it to the sibling repo and bump VENDOR_REV.
+// VENDOR_REV: 2
+import { randomUUID } from "node:crypto";
+import { replyChannel } from "./channels.js";
+/**
+ * Cross-extension request/reply over the in-process pi event bus.
+ *
+ * Wire contract (matches the pi-mono convention used by @tintinweb/pi-subagents):
+ *   request:  emit(channel, { requestId, ...params })
+ *   reply:    emit(`${channel}:reply:${requestId}`, RpcReply)
+ */
+export const PROTOCOL_VERSION = 2;
+export class RpcError extends Error {
+    channel;
+    timedOut;
+    constructor(channel, message, timedOut = false) {
+        super(message);
+        this.channel = channel;
+        this.timedOut = timedOut;
+        this.name = "RpcError";
+    }
+}
+/**
+ * Call a remote handler and await its reply.
+ *
+ * Rejects with RpcError on a failure envelope or on timeout (timedOut=true).
+ * Callers that treat failure as "fall back" wrap this in try/catch at the
+ * layer that knows the fallback — the RPC layer itself never returns sentinels.
+ */
+export function rpcCall(bus, channel, params = {}, timeoutMs = 5000) {
+    const requestId = randomUUID();
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            unsub();
+            reject(new RpcError(channel, `${channel} timed out after ${timeoutMs}ms`, true));
+        }, timeoutMs);
+        const unsub = bus.on(replyChannel(channel, requestId), (raw) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            unsub();
+            const reply = raw;
+            if (reply?.success) {
+                resolve(reply.data);
+            }
+            else {
+                const error = reply && "error" in reply ? reply.error : undefined;
+                reject(new RpcError(channel, error ?? `${channel} replied with a malformed envelope`));
+            }
+        });
+        try {
+            bus.emit(channel, { requestId, ...params });
+        }
+        catch (error) {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                unsub();
+                reject(error);
+            }
+        }
+    });
+}
+/**
+ * Detection probe: resolves undefined when nobody answers the ping channel.
+ * Absence of a provider is expected, not an error.
+ *
+ * First reply wins. If the probing extension also serves this channel, its
+ * own reply will settle the probe — in that case listen on the reply channel
+ * directly for the full window and filter by PingReply.provider instead.
+ */
+export async function rpcProbe(bus, pingChannel, timeoutMs = 5000) {
+    try {
+        return await rpcCall(bus, pingChannel, {}, timeoutMs);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Register a server handler for one RPC channel. Returns the unsubscribe fn.
+ *
+ * Malformed requests get a failure reply, never a silent drop — the only
+ * silent case is a missing requestId, which leaves no reply address.
+ * A thrown/rejected fn becomes a failure envelope.
+ */
+export function handleRpc(bus, channel, fn, opts) {
+    return bus.on(channel, async (raw) => {
+        if (opts?.enabled && !opts.enabled())
+            return;
+        const requestId = raw && typeof raw === "object"
+            ? raw.requestId
+            : undefined;
+        if (typeof requestId !== "string" || requestId.length === 0) {
+            opts?.debug?.(`${channel} — dropped request without requestId`);
+            return;
+        }
+        let reply;
+        try {
+            const result = await fn(raw);
+            reply = result === undefined ? { success: true } : { success: true, data: result };
+        }
+        catch (error) {
+            reply = {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+        bus.emit(replyChannel(channel, requestId), reply);
+    });
+}

package/dist/runtime/loop-events.d.ts

@@ -0,0 +1,26 @@
+import type { LoopEntry } from "../types.js";
+export type LoopAutoDeleteReason = "task_backlog_empty";
+export interface LoopAutodeletedPayload {
+    loopId: string;
+    prompt: string;
+    trigger: LoopEntry["trigger"];
+    recurring: boolean;
+    autoTask?: boolean;
+    taskBacklog?: boolean;
+    readOnly?: boolean;
+    maxFires?: number;
+    fireCount?: number;
+    createdAt: number;
+    updatedAt: number;
+    expiresAt: number;
+    source: "task_backlog_runtime";
+    reason: LoopAutoDeleteReason;
+    pendingCount: number;
+}
+export interface TaskBacklogEmptyPayload {
+    pendingCount: 0;
+    deletedLoopIds: string[];
+    source: "task_backlog_runtime";
+}
+export declare function buildLoopAutodeletedPayload(entry: LoopEntry, pendingCount: number): LoopAutodeletedPayload;
+export declare function buildTaskBacklogEmptyPayload(deletedLoopIds: string[]): TaskBacklogEmptyPayload;

package/dist/runtime/loop-events.js

@@ -0,0 +1,26 @@
+export function buildLoopAutodeletedPayload(entry, pendingCount) {
+    return {
+        loopId: entry.id,
+        prompt: entry.prompt,
+        trigger: entry.trigger,
+        recurring: entry.recurring,
+        autoTask: entry.autoTask,
+        taskBacklog: entry.taskBacklog,
+        readOnly: entry.readOnly,
+        maxFires: entry.maxFires,
+        fireCount: entry.fireCount,
+        createdAt: entry.createdAt,
+        updatedAt: entry.updatedAt,
+        expiresAt: entry.expiresAt,
+        source: "task_backlog_runtime",
+        reason: "task_backlog_empty",
+        pendingCount,
+    };
+}
+export function buildTaskBacklogEmptyPayload(deletedLoopIds) {
+    return {
+        pendingCount: 0,
+        deletedLoopIds,
+        source: "task_backlog_runtime",
+    };
+}

package/dist/runtime/monitor-ondone-runtime.js

@@ -37,7 +37,7 @@ export function createMonitorOnDoneRuntime(options) {
             return;
         const monitor = monitorManager.get(monitorId);
         if (monitor && monitor.status !== "running") {
-            if (monitor.status === "completed") {
+            if (monitor.status === "completed" || monitor.status === "error") {
                 deliver();
                 return;
             }

package/dist/runtime/native-task-rpc.d.ts

@@ -0,0 +1,22 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { TaskStore } from "../task-store.js";
+import { type TaskBacklogResult } from "./task-mutations.js";
+/** Discriminates pi-loop's own ping replies from an external pi-tasks provider. */
+export declare const NATIVE_TASKS_PROVIDER = "pi-loop-native";
+export interface NativeTaskRpcOptions {
+    pi: ExtensionAPI;
+    getNativeTaskStore: () => TaskStore | undefined;
+    /** Stands the server down (silent no-op) when an external pi-tasks owns the channels. */
+    isEnabled?: () => boolean;
+    /**
+     * Gates the mutating/reading verbs (create/update/pending/clean) until the
+     * pi-tasks detection probe has settled. Ping stays answerable throughout so
+     * providers remain discoverable, but no state diverges while an external
+     * provider might still claim the channels. Defaults to settled.
+     */
+    isDetectionSettled?: () => boolean;
+    evaluateTaskBacklog: (taskStore: TaskStore, pendingCount: number) => Promise<TaskBacklogResult>;
+    updateWidget: () => void;
+    debug?: (...args: unknown[]) => void;
+}
+export declare function registerNativeTaskRpc(options: NativeTaskRpcOptions): void;

package/dist/runtime/native-task-rpc.js

@@ -0,0 +1,50 @@
+import { TASKS_RPC, } from "../rpc/channels.js";
+import { handleRpc, PROTOCOL_VERSION } from "../rpc/cross-extension-rpc.js";
+import { cleanTasks, createTask, updateTask, } from "./task-mutations.js";
+/** Discriminates pi-loop's own ping replies from an external pi-tasks provider. */
+export const NATIVE_TASKS_PROVIDER = "pi-loop-native";
+export function registerNativeTaskRpc(options) {
+    const { pi, getNativeTaskStore, isEnabled, isDetectionSettled, evaluateTaskBacklog, updateWidget, debug, } = options;
+    const rpcOpts = { enabled: isEnabled, debug };
+    const settledRpcOpts = {
+        enabled: () => (isEnabled ? isEnabled() : true) && (isDetectionSettled ? isDetectionSettled() : true),
+        debug,
+    };
+    function requireMutationContext() {
+        const taskStore = getNativeTaskStore();
+        if (!taskStore)
+            throw new Error("native task store unavailable");
+        return { pi, taskStore, evaluateTaskBacklog, updateWidget };
+    }
+    handleRpc(pi.events, TASKS_RPC.ping, () => ({ version: PROTOCOL_VERSION, provider: NATIVE_TASKS_PROVIDER }), rpcOpts);
+    handleRpc(pi.events, TASKS_RPC.pending, () => ({ pending: requireMutationContext().taskStore.pendingCount() }), settledRpcOpts);
+    handleRpc(pi.events, TASKS_RPC.create, async (request) => {
+        if (!request.subject || !request.description) {
+            throw new Error("subject and description are required");
+        }
+        const { entry } = await createTask(requireMutationContext(), {
+            subject: request.subject,
+            description: request.description,
+            metadata: request.metadata,
+        });
+        return { id: entry.id, task: entry };
+    }, settledRpcOpts);
+    handleRpc(pi.events, TASKS_RPC.clean, async () => {
+        const pruned = await cleanTasks(requireMutationContext());
+        debug?.(`${TASKS_RPC.clean} — pruned ${pruned} completed task(s)`);
+        return { pruned };
+    }, settledRpcOpts);
+    handleRpc(pi.events, TASKS_RPC.update, async (request) => {
+        if (!request.id)
+            throw new Error("id is required");
+        const result = await updateTask(requireMutationContext(), {
+            id: request.id,
+            status: request.status,
+            subject: request.subject,
+            description: request.description,
+        });
+        if (!result)
+            throw new Error(`Task #${request.id} not found`);
+        return { task: result.entry };
+    }, settledRpcOpts);
+}

package/dist/runtime/notification-runtime.d.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { Trigger } from "../types.js";
+import type { DynamicLoopState, Trigger } from "../types.js";
 export interface LoopFireEvent {
     loopId: string;
     prompt: string;
@@ -8,6 +8,7 @@ export interface LoopFireEvent {
     readOnly?: boolean;
     recurring?: boolean;
     autoTask?: boolean;
+    dynamic?: DynamicLoopState;
 }
 export interface PendingNotification extends LoopFireEvent {
     key: string;

package/dist/runtime/notification-runtime.js

@@ -1,4 +1,5 @@
 import { createCoordinator, } from "../coordinator.js";
+import { formatTrigger } from "../loop-format.js";
 import { reduceNotificationState, } from "../notification-reducer.js";
 export function createNotificationRuntime(options) {
     const { pi, hasPendingTasks, cleanDoneTasks, getHasPendingMessages, debug } = options;
@@ -43,18 +44,28 @@ export function createNotificationRuntime(options) {
         });
     }
     function buildLoopFireMessage(data) {
-        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 triggerInfo = formatTrigger(data.trigger, "notification");
         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."
             : "";
+        if (data.dynamic || (typeof data.trigger !== "string" && data.trigger?.type === "dynamic")) {
+            const dynamic = data.dynamic;
+            const lines = [
+                `[pi-loop] Loop #${loopId} fired (dynamic).${constraint}`,
+                `Goal: ${dynamic?.goal ?? prompt}`,
+                `Iteration: ${dynamic?.iteration ?? 0}`,
+            ];
+            if (dynamic?.state)
+                lines.push(`State: ${dynamic.state}`);
+            if (dynamic?.metrics)
+                lines.push(`Metrics: ${dynamic.metrics}`);
+            if (dynamic?.doneCriteria)
+                lines.push(`Done criteria: ${dynamic.doneCriteria}`);
+            lines.push("Continue toward the goal. When done call LoopUpdate with status=\"completed\". If more work remains, call LoopUpdate with status=\"continue\" plus state/metrics. Omit nextInterval for idle-driven rewake; include nextInterval for a timed wake. If blocked, use status=\"paused\".");
+            return lines.join("\n");
+        }
         return [
             `[pi-loop] Loop #${loopId} fired (${triggerInfo}).${constraint}`,
             prompt,
@@ -88,6 +99,7 @@ export function createNotificationRuntime(options) {
                 recurring: notification.recurring,
                 readOnly: notification.readOnly,
                 autoTask: notification.autoTask,
+                dynamic: notification.dynamic,
                 timestamp: notification.timestamp,
             },
         }, {

package/dist/runtime/task-backlog-runtime.d.ts

@@ -1,5 +1,6 @@
 import type { TaskStore } from "../task-store.js";
-import type { LoopEntry, Trigger } from "../types.js";
+import type { LoopDeletionTombstoneInput, LoopEntry, Trigger } from "../types.js";
+import { type LoopAutodeletedPayload, type TaskBacklogEmptyPayload } from "./loop-events.js";
 export declare const AUTO_TASK_WORKER_THRESHOLD = 5;
 export declare 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 {
@@ -10,12 +11,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;
 }
 export interface TaskBacklogRuntime {

package/dist/runtime/task-backlog-runtime.js

@@ -1,9 +1,10 @@
 import { createCoordinator, } from "../coordinator.js";
 import { reduceTaskBacklogEvent, } from "../task-backlog-coordinator.js";
+import { buildLoopAutodeletedPayload, buildTaskBacklogEmptyPayload, } 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.";
 export function createTaskBacklogRuntime(options) {
-    const { getLoops, createLoop, deleteLoop, addTrigger, removeTrigger, updateWidget, hasPendingTasks, bootstrapTaskLoop, triggerHasEventSource, debug, } = options;
+    const { getLoops, createLoop, deleteLoop, recordDeletionTombstone, addTrigger, removeTrigger, updateWidget, hasPendingTasks, bootstrapTaskLoop, triggerHasEventSource, emitLoopAutodeleted, emitTaskBacklogEmpty, debug, } = options;
     function isAutoTaskWorkerLoop(entry) {
         return entry.status === "active"
             && entry.prompt === AUTO_TASK_WORKER_PROMPT
@@ -17,6 +18,13 @@ export function createTaskBacklogRuntime(options) {
     function findAutoTaskWorkerLoop() {
         return getLoops().find(isAutoTaskWorkerLoop);
     }
+    function deleteTaskBacklogLoop(entry, pendingCount) {
+        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() {
         const backlogLoops = getLoops().filter(isTaskBacklogLoop);
         if (backlogLoops.length === 0)
@@ -24,11 +32,10 @@ export function createTaskBacklogRuntime(options) {
         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;
     }
@@ -40,7 +47,7 @@ export function createTaskBacklogRuntime(options) {
             return { entry: existing, created: false };
         const trigger = {
             type: "hybrid",
-            cron: "*/5 * * * *",
+            cron: "*/3 * * * *",
             event: { source: "tasks:created" },
             debounceMs: 30000,
         };

package/dist/runtime/task-mutations.d.ts

@@ -0,0 +1,39 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { TaskStore } from "../task-store.js";
+import type { TaskEntry, TaskStatus } from "../task-types.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;
+}
+export declare function createTask(ctx: TaskMutationContext, params: {
+    subject: string;
+    description: string;
+    metadata?: Record<string, unknown>;
+}): Promise<{
+    entry: TaskEntry;
+    backlog: TaskBacklogResult;
+}>;
+export declare function updateTask(ctx: TaskMutationContext, params: UpdateTaskFields): Promise<{
+    entry: TaskEntry;
+    backlog: TaskBacklogResult;
+} | undefined>;
+export declare function deleteTask(ctx: TaskMutationContext, id: string): Promise<{
+    entry: TaskEntry;
+    backlog: TaskBacklogResult;
+} | undefined>;
+export declare function cleanTasks(ctx: TaskMutationContext): Promise<number>;

package/dist/runtime/task-mutations.js

@@ -0,0 +1,68 @@
+import { emitNativeTaskEvent } from "./task-events.js";
+/**
+ * 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) {
+    ctx.updateWidget();
+    return await ctx.evaluateTaskBacklog(ctx.taskStore, ctx.taskStore.pendingCount());
+}
+export async function createTask(ctx, params) {
+    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, params) {
+    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, id) {
+    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) {
+    const pruned = ctx.taskStore.pruneCompleted();
+    await settle(ctx);
+    return pruned;
+}

package/dist/runtime/task-rpc.d.ts

@@ -8,6 +8,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;
 }
 export interface TaskRuntimeBridge {

package/dist/runtime/task-rpc.js

@@ -1,49 +1,54 @@
 import { randomUUID } from "node:crypto";
+import { replyChannel, TASKS_RPC, } from "../rpc/channels.js";
+import { rpcCall } from "../rpc/cross-extension-rpc.js";
+import { NATIVE_TASKS_PROVIDER } from "./native-task-rpc.js";
 import { emitNativeTaskEvent } from "./task-events.js";
 export function createTaskRuntimeBridge(options) {
-    const { pi, isTasksAvailable, setTasksAvailable, getNativeTaskStore, onNativeTaskCreated, onNativeTasksPruned, debug, } = options;
+    const { pi, isTasksAvailable, setTasksAvailable, 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) => {
+        const unsub = pi.events.on(replyChannel(TASKS_RPC.ping, requestId), (raw) => {
+            const reply = raw;
+            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?.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) {
         if (!entry.autoTask)
             return undefined;
         if (isTasksAvailable()) {
             try {
-                const requestId = randomUUID();
-                const taskId = await new Promise((resolve) => {
-                    const timer = setTimeout(() => {
-                        unsub();
-                        resolve(undefined);
-                    }, 5000);
-                    const unsub = pi.events.on(`tasks:rpc:create:reply:${requestId}`, (raw) => {
-                        unsub();
-                        clearTimeout(timer);
-                        const reply = raw;
-                        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(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;
@@ -59,22 +64,11 @@ export function createTaskRuntimeBridge(options) {
     }
     async function hasPendingTasks() {
         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((resolve) => {
-                    const timer = setTimeout(() => {
-                        unsub();
-                        resolve(-1);
-                    }, 3000);
-                    const unsub = pi.events.on(`tasks:rpc:pending:reply:${requestId}`, (raw) => {
-                        unsub();
-                        clearTimeout(timer);
-                        const reply = raw;
-                        resolve(reply.success && reply.data ? reply.data.pending : -1);
-                    });
-                    pi.events.emit("tasks:rpc:pending", { requestId });
-                });
-                return count;
+                const reply = await rpcCall(pi.events, TASKS_RPC.pending, {}, 3000);
+                return reply.pending;
             }
             catch {
                 return -1;
@@ -85,20 +79,8 @@ export function createTaskRuntimeBridge(options) {
     async function cleanDoneTasks() {
         if (isTasksAvailable()) {
             try {
-                const requestId = randomUUID();
-                await new Promise((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(pi.events, TASKS_RPC.clean, {}, 3000);
+                debug?.(`${TASKS_RPC.clean} — done tasks swept`);
             }
             catch {
                 // timeout or error, ignore