pi-orchestrator-config 4.3.11 → 4.3.13

package/extensions/orchestrator/cron.ts

@@ -1,736 +1,205 @@
-/**
- * Cron-like scheduled tasks — pi-process-scoped.
- *
- * Tasks survive /reload, /resume, /new but die on pi exit.
- * Persisted to a session-scoped file so they survive extension re-evaluation.
- *
- * The /cron command is a natural-language interface — the AI parses
- * the user's intent and calls the cron_manage tool with structured params.
- *
- * Slash command tasks (starting with /) execute as commands.
- * Prompt tasks run as async agents with triggerTurn: true.
- */
-
-import { createLogger } from "../shared/logger.js";
-
-const log = createLogger("cron");
+/** Cron tasks with session and project scopes. Durable project delivery is at-least-once. */
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { getProjectTmpDir } from "./utils.js";
 import { Type } from "typebox";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createLogger } from "../shared/logger.js";
 import { decideAsyncLlmDispatch } from "./async-capability.js";
-import { discoverAgents } from "./agents.js";
 import { formatCronSchedule, toCronStatusTaskView } from "./cron-status-format.js";
 import { openCronStatusOverlay } from "./cron-status-ui.js";
 import { setSlot } from "./status-bar.js";
-import { getProjectTmpDir, parseProcStartTime } from "./utils.js";
-
-// ── Types ────────────────────────────────────────────────────────────
-
-export interface CronTask {
-  id: number;
-  description: string; // human-readable description
-  task: string; // what to execute
-  intervalMs?: number; // for interval-based
-  atHour?: number; // for time-based (daily)
-  atMinute?: number;
-  createdAt: number;
-  lastRun?: number;
-  nextRun?: number;
-}
-
-/** Shared mutable state + helpers passed to extracted registration functions */
-interface CronInternals {
-  tasks: Map<number, CronTask>;
-  nextId: number;
-  lastCwd: string;
-  lastCtx: any;
-  startTask(task: CronTask): void;
-  stopTask(id: number): void;
-  updateCronStatus(): void;
-}
-
-// ── Persistence ──────────────────────────────────────────────────────
-
-let CRON_FILE = ""; // Set on session_start to project-scoped dir
-/** Ignore fs.watch echoes from our own writes. */
-let CRON_IGNORE_WATCH_UNTIL = 0;
+import { acquireLeaderLock, durableCronSupported, mutateDurableCronStore, readDurableCronStore, refreshLeaderLock, releaseLeaderLock, validateDurableCronTask, type CronLockOwner, type CronScope, type DurableCronTask } from "./cron-store.js";
 
-/** Unique session suffix — prevents PID collisions across containers */
-/** Suffix must be unique across containers but stable across reloads (same process).
- *  Use process start time from /proc or process.uptime() as a stable identifier. */
-const SESSION_SUFFIX = (() => {
-  try {
-    const stat = fs.readFileSync("/proc/self/stat", "utf-8");
-    const startTime = parseProcStartTime(stat);
-    if (!startTime) throw new Error("failed to parse start time");
-    return `${process.pid}-${startTime}`;
-  } catch {
-    const seed = `${process.pid}-${process.ppid}-${process.argv.join(",")}`;
-    let hash = 0;
-    for (let i = 0; i < seed.length; i++) {
-      hash = ((hash << 5) - hash + seed.charCodeAt(i)) | 0;
-    }
-    return `${process.pid}-${Math.abs(hash).toString(36)}`;
-  }
-})();
-
-/** Matches both old (cron-{pid}.json) and new (cron-{pid}-{suffix}.json) formats */
-const CRON_FILE_RE = /^cron-(\d+)(?:-[^.]+)?\.json$/;
-
-/** Get current cron file path — used by autocomplete */
-export function getCronFilePath(): string { return CRON_FILE; }
-
-function saveCrons(tasks: CronTask[]): void {
-  if (!CRON_FILE) return;
-  try {
-    CRON_IGNORE_WATCH_UNTIL = Date.now() + 400;
-    fs.writeFileSync(CRON_FILE, JSON.stringify(tasks), { mode: 0o600 });
-  } catch (e: any) { log.debug("save crons failed:", e?.message || e); }
+const log = createLogger("cron");
+export interface CronTask { id: string; scope: CronScope; cwd: string; description: string; task: string; intervalMs?: number; atHour?: number; atMinute?: number; createdAt: number; lastRun?: number; nextRun?: number; leader?: boolean; }
+type Timer = ReturnType<typeof setTimeout> | ReturnType<typeof setInterval>;
+const durable = (scope: CronScope) => scope === "project";
+let sessionStore = "";
+function sessionStoreFor(ctx: any): string {
+  let id: unknown;
+  try { id = ctx.sessionManager?.getSessionId?.(); } catch { return ""; }
+  // A process ID survives /new. Only pi's session ID preserves session scope across /reload.
+  return typeof id === "string" && id ? path.join(getProjectTmpDir(ctx.cwd), `cron-${createHash("sha256").update(id).digest("hex")}.json`) : "";
 }
-
-function loadCrons(): CronTask[] {
-  if (!CRON_FILE) return [];
-  try {
-    const data = JSON.parse(fs.readFileSync(CRON_FILE, "utf-8"));
-    return Array.isArray(data) ? data : [];
-  } catch {
-    return [];
-  }
+function readSessionTasks(file: string): unknown[] {
+  try { const value = JSON.parse(fs.readFileSync(file, "utf8")); return Array.isArray(value) ? value : []; } catch { return []; }
 }
-
-function cleanupOrphanedCronFiles(): void {
-  try {
-    const dir = path.dirname(CRON_FILE);
-    const myFile = path.basename(CRON_FILE);
-    for (const f of fs.readdirSync(dir)) {
-      const m = f.match(CRON_FILE_RE);
-      if (!m || f === myFile) continue;
-      // Old format (no suffix) — always delete (legacy)
-      const isLegacy = /^cron-\d+\.json$/.test(f);
-      if (isLegacy) {
-        try { fs.unlinkSync(path.join(dir, f)); } catch {}
-        continue;
-      }
-      // New format — extract PID and suffix token
-      const pid = +m[1];
-      const suffixMatch = f.match(/^cron-\d+-(.+)\.json$/);
-      const fileToken = suffixMatch?.[1];
-      // Check /proc/{pid}/stat — if we can read it, verify start time matches
-      try {
-        const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf-8");
-        const startTime = parseProcStartTime(stat);
-        if (startTime && fileToken && startTime === fileToken) {
-          // Same PID, same start time — process is alive, skip
-          continue;
-        }
-        if (startTime && fileToken && startTime !== fileToken) {
-          // PID reused — different process, safe to delete
-          try { fs.unlinkSync(path.join(dir, f)); } catch {}
-          continue;
-        }
-      } catch {
-        // /proc/{pid} not readable — either dead process or different PID namespace
-        // Only delete if we can confirm PID is dead in our namespace
-        try { process.kill(pid, 0); } catch {
-          // PID dead in our namespace — safe to delete
-          try { fs.unlinkSync(path.join(dir, f)); } catch {}
-        }
-        // If kill(pid, 0) succeeds but /proc is unreadable — skip (can't verify)
-      }
-    }
-  } catch (e: any) { log.debug("cleanup orphaned cron files failed:", e?.message || e); }
+function validateSessionCronTask(task: unknown): asserts task is CronTask {
+  const value = task as CronTask;
+  if (!value || typeof value !== "object" || typeof value.id !== "string" || !value.id || typeof value.description !== "string" || typeof value.task !== "string" || !value.task.trim() || !Number.isFinite(value.createdAt)) throw new Error("Invalid session cron task");
+  validateSchedule({ interval_seconds: value.intervalMs === undefined ? undefined : value.intervalMs / 1000, at_hour: value.atHour, at_minute: value.atMinute });
+  if ((value.lastRun !== undefined && !Number.isFinite(value.lastRun)) || (value.nextRun !== undefined && !Number.isFinite(value.nextRun))) throw new Error("Invalid session cron timestamp");
 }
-
-// ── Helpers ──────────────────────────────────────────────────────────
-
-function formatSchedule(task: CronTask): string {
-  return formatCronSchedule(task);
+function writeSessionTasks(file: string, tasks: Iterable<CronTask>) {
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(file, JSON.stringify([...tasks]), { mode: 0o600 });
 }
-
-function msUntilNextTime(hour: number, minute: number): number {
-  const now = new Date();
-  const target = new Date(now);
-  target.setHours(hour, minute, 0, 0);
-  if (target.getTime() <= now.getTime()) {
-    target.setDate(target.getDate() + 1);
+export const qualifyCronId = (task: Pick<CronTask, "scope" | "id">) => `${task.scope === "project" ? "persist" : "session"}:${task.id}`;
+let currentCronTasks: () => Iterable<CronTask> = () => [];
+export function cronRemoveAutocompleteItems(tasks: Iterable<Pick<CronTask, "scope" | "id" | "description" | "task">>) {
+  const seen = new Set<string>();
+  const items = [];
+  for (const task of tasks) {
+    const id = qualifyCronId(task);
+    if (!seen.has(id)) { seen.add(id); items.push({ value: id, label: id, description: task.description || task.task }); }
   }
-  return target.getTime() - now.getTime();
+  return items;
 }
-
-// ── Extracted registration functions ─────────────────────────────────
-
-function registerCronTool(pi: ExtensionAPI, state: CronInternals): void {
-  pi.registerTool({
-    name: "cron_manage",
-    description: "Manage scheduled cron tasks. Use this tool when the user wants to schedule, list, or remove recurring tasks.",
-    parameters: Type.Object({
-      action: Type.Union([Type.Literal("add"), Type.Literal("list"), Type.Literal("list-all"), Type.Literal("remove")], {
-        description: "The action to perform",
-      }),
-      description: Type.Optional(Type.String({
-        description: "Human-readable description of the task (for 'add')",
-      })),
-      task: Type.Optional(Type.String({
-        description: "What to execute — a prompt for the AI or a /slash-command (for 'add')",
-      })),
-      interval_seconds: Type.Optional(Type.Number({
-        description: "Run every N seconds (for interval-based 'add'). Minimum 10 seconds.",
-      })),
-      at_hour: Type.Optional(Type.Number({
-        description: "Hour (0-23) for daily time-based schedule (for 'add')",
-      })),
-      at_minute: Type.Optional(Type.Number({
-        description: "Minute (0-59) for daily time-based schedule (for 'add')",
-      })),
-      id: Type.Optional(Type.Number({
-        description: "Task ID to remove (for 'remove')",
-      })),
-    }),
-    async execute(_id, params) {
-      const action = params.action as string;
-
-      if (action === "add") {
-        // Block scheduling in one-shot modes
-        if (state.lastCtx?.mode === "print" || state.lastCtx?.mode === "json") {
-          return { content: [{ type: "text", text: "Error: cron scheduling is not available in one-shot modes (print/json)" }] };
-        }
-        if (!params.task) {
-          return { content: [{ type: "text", text: "Error: 'task' is required for add action" }] };
-        }
-        if (!params.interval_seconds && params.at_hour === undefined) {
-          return { content: [{ type: "text", text: "Error: either 'interval_seconds' or 'at_hour'+'at_minute' is required" }] };
-        }
-
-        const intervalMs = params.interval_seconds ? Math.max(10, params.interval_seconds) * 1000 : undefined;
-        const atHour = params.at_hour !== undefined ? Math.max(0, Math.min(23, params.at_hour)) : undefined;
-        const atMinute = params.at_minute !== undefined ? Math.max(0, Math.min(59, params.at_minute)) : (atHour !== undefined ? 0 : undefined);
-
-        const task: CronTask = {
-          id: state.nextId++,
-          description: (params.description as string) || (params.task as string).slice(0, 60),
-          task: params.task as string,
-          intervalMs,
-          atHour,
-          atMinute,
-          createdAt: Date.now(),
-        };
-
-        state.tasks.set(task.id, task);
-        state.startTask(task);
-        saveCrons([...state.tasks.values()]);
-        log.info("cron_add", task.description);
-
-        state.updateCronStatus();
-        return {
-          content: [{
-            type: "text",
-            text: `Cron #${task.id} created: ${formatSchedule(task)} → ${task.description}`,
-          }],
-        };
-      }
-
-      if (action === "list") {
-        if (state.tasks.size === 0) {
-          return { content: [{ type: "text", text: "No scheduled tasks." }] };
-        }
-        const lines = [...state.tasks.values()].map(t => {
-          const last = t.lastRun ? new Date(t.lastRun).toLocaleTimeString() : "never";
-          return `#${t.id} | ${formatSchedule(t)} | ${t.description} | last run: ${last}`;
-        });
-        return {
-          content: [{ type: "text", text: `Scheduled tasks:\n\n${lines.join("\n")}` }],
-        };
-      }
-
-      if (action === "list-all") {
-        const sections: string[] = [];
-        if (!CRON_FILE) {
-          return { content: [{ type: "text", text: "No scheduled tasks in any session." }] };
-        }
-        try {
-          const dir = path.dirname(CRON_FILE);
-          for (const f of fs.readdirSync(dir)) {
-            const m = f.match(CRON_FILE_RE);
-            if (!m) continue;
-            const pid = +m[1];
-            const isMe = f === path.basename(CRON_FILE);
-            let alive = isMe;
-            if (!isMe) { try { process.kill(pid, 0); alive = true; } catch {} }
-            if (!alive) continue;
-            const cronTasks: CronTask[] = isMe
-              ? [...state.tasks.values()]
-              : (() => { try { return JSON.parse(fs.readFileSync(path.join(dir, f), "utf-8")); } catch { return []; } })();
-            if (cronTasks.length === 0) continue;
-            const label = isMe ? `PID ${pid} (this session)` : `PID ${pid}`;
-            const lines = cronTasks.map(t => {
-              const last = t.lastRun ? new Date(t.lastRun).toLocaleTimeString() : "never";
-              return `  #${t.id} | ${formatSchedule(t)} | ${t.description} | last run: ${last}`;
-            });
-            sections.push(`**${label}:**\n${lines.join("\n")}`);
-          }
-        } catch (e: any) { log.debug("list-all scan failed:", e?.message || e); }
-        if (sections.length === 0) {
-          return { content: [{ type: "text", text: "No scheduled tasks in any session." }] };
-        }
-        return {
-          content: [{ type: "text", text: `All sessions:\n\n${sections.join("\n\n")}` }],
-        };
-      }
-
-      if (action === "remove") {
-        const id = params.id as number;
-        if (!id || !state.tasks.has(id)) {
-          return { content: [{ type: "text", text: `Task #${id || "?"} not found.` }] };
-        }
-        const task = state.tasks.get(id)!;
-        state.stopTask(id);
-        state.tasks.delete(id);
-        saveCrons([...state.tasks.values()]);
-        log.info("cron_remove", id);
-        state.updateCronStatus();
-        return {
-          content: [{ type: "text", text: `Cron #${id} removed: ${task.description}` }],
-        };
-      }
-
-      return { content: [{ type: "text", text: `Unknown action: ${action}` }] };
-    },
-  });
+export function getCronRemoveAutocompleteItems() { return cronRemoveAutocompleteItems(currentCronTasks()); }
+export function parseCronScope(args: string[]): { scope: CronScope; rest: string[]; error?: string } {
+  let scope: CronScope = "session"; const rest: string[] = [];
+  for (const arg of args) {
+    if (arg === "--persist") { scope = "project"; continue; }
+    if (arg === "--scope" || arg === "--project") return { scope, rest, error: `"${arg}" is not supported; use --persist for a persistent cron` };
+    rest.push(arg);
+  }
+  return { scope, rest };
 }
-
-function listLocalCronViews(state: CronInternals) {
-  const file = CRON_FILE || "";
-  return [...state.tasks.values()].map((t) =>
-    toCronStatusTaskView(t, {
-      overlayId: String(t.id),
-      isLocal: true,
-      cronFile: file,
-    }),
-  );
+function projectStore(cwd: string) { return path.join(cwd, ".pi", "cron", "crons.json"); }
+function validateSchedule(details: any) {
+  const interval = details.interval_seconds;
+  const hour = details.at_hour;
+  const minute = details.at_minute;
+  if (interval !== undefined && (!Number.isFinite(interval) || interval < 10)) throw new Error("interval_seconds must be finite and at least 10 seconds");
+  if (hour !== undefined && (!Number.isInteger(hour) || hour < 0 || hour > 23)) throw new Error("at_hour must be an integer from 0 to 23");
+  if (minute !== undefined && (!Number.isInteger(minute) || minute < 0 || minute > 59)) throw new Error("at_minute must be an integer from 0 to 59");
+  if (minute !== undefined && hour === undefined) throw new Error("at_minute requires at_hour");
 }
+function nextDelay(task: CronTask) { if (task.intervalMs) return task.intervalMs; const target = new Date(); target.setHours(task.atHour!, task.atMinute!, 0, 0); if (+target <= Date.now()) target.setDate(target.getDate() + 1); return +target - Date.now(); }
 
-function listAllCronViews(state: CronInternals) {
-  const views: ReturnType<typeof toCronStatusTaskView>[] = [];
-  if (!CRON_FILE) return views;
-  try {
-    const dir = path.dirname(CRON_FILE);
-    const myBase = path.basename(CRON_FILE);
-    for (const f of fs.readdirSync(dir)) {
-      const m = f.match(CRON_FILE_RE);
-      if (!m) continue;
-      const pid = +m[1];
-      const isMe = f === myBase;
-      let alive = isMe;
-      if (!isMe) {
-        try {
-          process.kill(pid, 0);
-          alive = true;
-        } catch {
-          /* dead */
-        }
-      }
-      if (!alive) continue;
-      const filePath = path.join(dir, f);
-      const cronTasks: CronTask[] = isMe
-        ? [...state.tasks.values()]
-        : (() => {
-            try {
-              const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-              if (!Array.isArray(parsed)) return [];
-              return parsed;
-            } catch {
-              return [];
-            }
-          })();
-      if (cronTasks.length === 0) continue;
-      const label = isMe ? `PID ${pid} (this session)` : `PID ${pid}`;
-      for (const t of cronTasks) {
-        views.push(
-          toCronStatusTaskView(t, {
-            overlayId: `${f}:${t.id}`,
-            sessionLabel: label,
-            isLocal: isMe,
-            cronFile: filePath,
-          }),
-        );
-      }
+export function registerCron(pi: ExtensionAPI, spawnAsyncAgent: any): { getCronTasks: () => CronTask[] } {
+  if (process.env.PI_SUBAGENT_CHILD === "1") return { getCronTasks: () => [] };
+  const tasks = new Map<string, CronTask>(); const timers = new Map<string, Timer>();
+  currentCronTasks = () => tasks.values();
+  const owned = new Map<string, CronLockOwner>(); const instanceId = randomUUID(); let ctx: any; let watchers: fs.FSWatcher[] = []; let health: ReturnType<typeof setInterval> | undefined;
+  function cleanupRuntime(releaseLocks = true) {
+    log.debug("cron_cleanup_runtime", { timers: timers.size, watchers: watchers.length, locks: owned.size, releaseLocks });
+    if (health) clearInterval(health); health = undefined;
+    for (const id of [...timers.keys()]) stop(id);
+    for (const watcher of watchers) try { watcher.close(); } catch (error: any) { log.warn("cron_watcher_close_failed", { code: error?.code }); }
+    watchers = [];
+    if (releaseLocks) for (const [file, owner] of owned) {
+      releaseLeaderLock(file, owner);
+      owned.delete(file);
     }
-  } catch (e: any) {
-    log.debug("list-all scan failed:", e?.message || e);
+    else owned.clear();
   }
-  return views;
-}
-
-function removeCronByOverlayId(state: CronInternals, overlayId: string): boolean {
-  const fromAll = listAllCronViews(state).find((v) => v.id === overlayId);
-  const fromLocal = listLocalCronViews(state).find((v) => v.id === overlayId);
-  const view = fromAll || fromLocal;
-  if (!view) return false;
-
-  if (view.isLocal || (view.cronFile && view.cronFile === CRON_FILE)) {
-    if (!state.tasks.has(view.taskId)) return false;
-    state.stopTask(view.taskId);
-    state.tasks.delete(view.taskId);
-    saveCrons([...state.tasks.values()]);
-    state.updateCronStatus();
-    return true;
+  const stores = () => ctx ? [{ scope: "project" as const, file: projectStore(ctx.cwd) }] : [];
+  function updateStatus() {
+    try { if (ctx?.hasUI) setSlot("crons", ctx.ui.theme.fg("muted", `⏰ ${tasks.size} cron${tasks.size === 1 ? "" : "s"}`), ctx); } catch {}
+    pi.events.emit("pidash:cron-status", { count: tasks.size, tasks: [...tasks.values()].map(t => ({ id: qualifyCronId(t), scope: t.scope, description: t.description, schedule: formatCronSchedule(t), lastRun: t.lastRun, nextRun: t.nextRun, leader: t.leader })) });
   }
-
-  // Other session — edit their JSON; their watcher (if running new code) resyncs timers.
-  if (!view.cronFile) return false;
-  try {
-    const raw = JSON.parse(fs.readFileSync(view.cronFile, "utf-8"));
-    if (!Array.isArray(raw)) return false;
-    const next = raw.filter((t: CronTask) => t.id !== view.taskId);
-    if (next.length === raw.length) return false;
-    fs.writeFileSync(view.cronFile, JSON.stringify(next), { mode: 0o600 });
-    return true;
-  } catch (e: any) {
-    log.debug("remote remove failed:", e?.message || e);
-    return false;
+  function persist(task: CronTask) {
+    try {
+      if (task.scope === "session") { if (sessionStore) writeSessionTasks(sessionStore, [...tasks.values()].filter(t => t.scope === "session")); return; }
+      mutateDurableCronStore(projectStore(task.cwd), old => old.map(t => t.id === task.id ? task as DurableCronTask : t));
+    } catch (error: any) { log.error("cron_persist_failed", qualifyCronId(task), error?.message || error); }
   }
-}
-
-function registerCronCommand(pi: ExtensionAPI, state: CronInternals): void {
-  pi.registerCommand("cron", {
-    description: "Schedule recurring tasks — /cron list|list-all|remove <id>|<natural language>",
-    handler: async (args, ctx) => {
-      state.lastCtx = ctx;
-      state.lastCwd = ctx.cwd;
-      const text = (args || "").trim();
-      const parts = text.split(/\s+/);
-      const sub = parts[0]?.toLowerCase();
-
-      // Direct handlers — no AI needed
-      if (sub === "list" && parts.length === 1) {
-        if (!ctx.hasUI) return;
-        await openCronStatusOverlay(ctx, {
-          listTasks: () => listLocalCronViews(state),
-          removeTask: (id) => removeCronByOverlayId(state, id),
-        });
-        return;
-      }
-
-      if (sub === "list-all") {
-        if (!ctx.hasUI) return;
-        await openCronStatusOverlay(ctx, {
-          title: "Cron tasks (all sessions)",
-          emptyMessage: "No crons in any session.",
-          borderTitle: (tasks) => {
-            const sessions = new Set(
-              tasks.map((t) => t.sessionLabel || "?").filter(Boolean),
-            );
-            return `all sessions · ${tasks.length} tasks · ${sessions.size} session${sessions.size === 1 ? "" : "s"}`;
-          },
-          listTasks: () => listAllCronViews(state),
-          removeTask: (id) => removeCronByOverlayId(state, id),
-        });
-        return;
-      }
-
-      if ((sub === "remove" || sub === "rm" || sub === "delete" || sub === "kill") && parts.length > 1) {
-        const ids = parts.slice(1).map(p => parseInt(p, 10)).filter(n => !isNaN(n));
-        if (ids.length === 0) {
-          if (ctx.hasUI) ctx.ui.notify("No valid task IDs. Use /cron list", "warning");
-          return;
-        }
-        const removed: string[] = [];
-        const notFound: string[] = [];
-        for (const id of ids) {
-          if (state.tasks.has(id)) {
-            const task = state.tasks.get(id)!;
-            state.stopTask(id);
-            state.tasks.delete(id);
-            removed.push(`#${id} (${task.description})`);
-          } else {
-            notFound.push(`#${id}`);
-          }
-        }
-        saveCrons([...state.tasks.values()]);
-        state.updateCronStatus();
-        const lines: string[] = [];
-        if (removed.length) lines.push(`Removed: ${removed.join(", ")}`);
-        if (notFound.length) lines.push(`Not found: ${notFound.join(", ")}`);
-        if (ctx.hasUI) ctx.ui.notify(lines.join("\n"), removed.length ? "info" : "warning");
-        return;
-      }
-
-      if (!text) {
-        if (ctx.hasUI) ctx.ui.notify("Usage:\n/cron <natural language task>\n/cron list\n/cron list-all\n/cron remove <id>", "info");
-        return;
-      }
-
-      // Only "add" goes through the AI for natural language parsing
-      pi.sendUserMessage(
-        `The user wants to schedule a cron task. Parse their request and use the cron_manage tool with action "add".\n\nUser request: "${text}"\n\nInterpret the schedule and task from the natural language. For interval-based schedules, convert to seconds. For time-based schedules, extract hour and minute.`,
-        { deliverAs: "followUp" },
-      );
-    },
-  });
-}
-
-// ── Registration ─────────────────────────────────────────────────────
-
-export function registerCron(
-  pi: ExtensionAPI,
-  spawnAsyncAgent: (
-    agentName: string,
-    task: string,
-    cwd: string,
-    agents: any[],
-    options?: {
-      fireAndForget?: boolean;
-      name?: string;
-      parentModelId?: string;
-      parentProvider?: string;
-    },
-  ) => { id: string; error?: string },
-): { getCronTasks: () => CronTask[] } {
-  if (process.env.PI_SUBAGENT_CHILD === "1") return { getCronTasks: () => [] };
-
-  const tasks = new Map<number, CronTask>();
-  const timers = new Map<number, ReturnType<typeof setTimeout> | ReturnType<typeof setInterval>>();
-
-  const state: CronInternals = {
-    tasks,
-    nextId: 1,
-    lastCwd: "",
-    lastCtx: null,
-    startTask,
-    stopTask,
-    updateCronStatus,
-  };
-
-  function updateCronStatus() {
-    const count = tasks.size;
-    saveCrons([...tasks.values()]);
+  async function execute(task: CronTask) {
     try {
-      if (state.lastCtx?.hasUI) {
-        if (count > 0) {
-          setSlot("crons", state.lastCtx.ui.theme.fg("muted", `⏰ ${count} cron${count > 1 ? "s" : ""}`), state.lastCtx);
-        } else {
-          setSlot("crons", state.lastCtx.ui.theme.fg("muted", `⏰ 0 crons`), state.lastCtx);
-        }
-      }
-    } catch { /* stale ctx after session replacement */ }
-    pi.events.emit("pidash:cron-status", {
-      count,
-      tasks: [...tasks.values()].map(t => ({
-        id: t.id,
-        description: t.description,
-        schedule: formatSchedule(t),
-        lastRun: t.lastRun,
-        nextRun: t.nextRun,
-      })),
-    });
+      if (durable(task.scope) && !task.leader) return;
+      task.lastRun = Date.now(); persist(task); updateStatus(); log.info("cron_execute", qualifyCronId(task));
+      const cmd = task.task.trim();
+      if (cmd.startsWith("/")) { pi.sendUserMessage(cmd, { deliverAs: "followUp" }); return; }
+      const dispatch = decideAsyncLlmDispatch({ parentProvider: ctx?.model?.provider, cwd: task.cwd, mustAsync: true });
+      if (dispatch.action === "skip") { log.error("cron_error", qualifyCronId(task), dispatch.note); return; }
+      const { discoverAgents } = await import("./agents.js");
+      const { agents } = discoverAgents(task.cwd, "user");
+      spawnAsyncAgent("worker", cmd, task.cwd, agents, { name: `Cron: ${task.description.slice(0, 40)}`, ...(dispatch.action === "sidecar-async" ? { parentProvider: dispatch.sidecar.provider, parentModelId: dispatch.sidecar.model } : {}) });
+    } catch (error: any) { log.error("cron_execute_failed", qualifyCronId(task), error?.message || error); }
   }
-
-  function executeCronTask(task: CronTask) {
-    log.info("cron_execute", task.id);
-    task.lastRun = Date.now();
-    saveCrons([...tasks.values()]);
-
-    const cmd = task.task.trim();
-
-    if (cmd.startsWith("/")) {
-      // Slash command — send as user message
-      pi.sendUserMessage(cmd, { deliverAs: "followUp" });
-    } else {
-      // Prompt task — run as async agent, result surfaces to AI
-      const cwd = state.lastCwd || process.cwd();
-      const parentProvider = state.lastCtx?.model?.provider as string | undefined;
-      const dispatch = decideAsyncLlmDispatch({
-        parentProvider,
-        cwd,
-        mustAsync: true,
-      });
-      if (dispatch.action === "skip") {
-        log.error("cron_error", task.id, dispatch.note);
-        try {
-          state.lastCtx?.ui?.notify?.(
-            `Cron #${task.id} skipped: set internal_operations_provider/internal_operations_model for acpx`,
-            "warning",
-          );
-        } catch { /* stale UI */ }
-        return;
-      }
-      const { agents } = discoverAgents(cwd, "user");
-      const sidecarOpts =
-        dispatch.action === "sidecar-async"
-          ? {
-              parentProvider: dispatch.sidecar.provider,
-              parentModelId: dispatch.sidecar.model,
-            }
-          : {};
-      spawnAsyncAgent("worker", cmd, cwd, agents, {
-        name: `Cron: ${task.description.slice(0, 40)}`,
-        ...sidecarOpts,
-      });
-    }
+  function stop(id: string) { const timer = timers.get(id); if (timer) { clearTimeout(timer as any); clearInterval(timer as any); timers.delete(id); } }
+  function start(task: CronTask) {
+    stop(task.id); if (durable(task.scope) && !task.leader) return;
+    const schedule = (runAt = task.nextRun ?? Date.now() + nextDelay(task)) => {
+      const delay = Math.max(0, runAt - Date.now());
+      const timer = setTimeout(async () => { try { await execute(task); schedule(Date.now() + nextDelay(task)); } catch (error: any) { log.error("cron_timer_failed", qualifyCronId(task), error?.message || error); } }, delay);
+      task.nextRun = runAt; persist(task); updateStatus(); timer.unref?.(); timers.set(task.id, timer);
+    };
+    schedule();
   }
-
-  function startTask(task: CronTask) {
-    const existing = timers.get(task.id);
-    if (existing) { clearTimeout(existing as any); clearInterval(existing as any); }
-
-    if (task.intervalMs) {
-      const timer = setInterval(() => executeCronTask(task), task.intervalMs);
-      if ((timer as any).unref) (timer as any).unref();
-      timers.set(task.id, timer);
-    } else if (task.atHour !== undefined && task.atMinute !== undefined) {
-      const scheduleNext = () => {
-        const ms = msUntilNextTime(task.atHour!, task.atMinute!);
-        task.nextRun = Date.now() + ms;
-        saveCrons([...tasks.values()]);
-        const timer = setTimeout(() => {
-          executeCronTask(task);
-          scheduleNext();
-        }, ms);
-        if (timer.unref) timer.unref();
-        timers.set(task.id, timer);
-      };
-      scheduleNext();
+  function syncStore(scope: "project", file: string) {
+    const leader = owned.has(file); const disk = readDurableCronStore(file).tasks;
+    for (const old of [...tasks.values()]) if (old.scope === scope && !disk.some(t => t.id === old.id)) { stop(old.id); tasks.delete(old.id); }
+    for (const raw of disk) {
+      try { validateDurableCronTask(raw); } catch (error: any) { log.error("invalid durable cron ignored", raw && typeof raw === "object" ? (raw as any).id : "unknown", error?.message || error); continue; }
+      const task: CronTask = { ...raw, leader }; const existing = tasks.get(task.id);
+      if (!existing) { tasks.set(task.id, task); start(task); } else { const changed = existing.intervalMs !== task.intervalMs || existing.atHour !== task.atHour || existing.atMinute !== task.atMinute || existing.leader !== leader; Object.assign(existing, task); if (changed) start(existing); }
     }
   }
-
-  function stopTask(id: number) {
-    const timer = timers.get(id);
-    if (timer) {
-      clearTimeout(timer as any);
-      clearInterval(timer as any);
-      timers.delete(id);
+  function election() {
+    for (const { scope, file } of stores()) {
+      let owner = owned.get(file); if (owner && !refreshLeaderLock(file, owner)) { owned.delete(file); owner = undefined; }
+      if (!owner) { owner = acquireLeaderLock(file, instanceId) || undefined; if (owner) { owned.set(file, owner); log.info("cron_leader_acquired", scope); } }
+      syncStore(scope, file);
     }
+    updateStatus();
   }
-
-  /** Resync in-memory tasks from CRON_FILE (external list-all remove / peer edit). */
-  function syncTasksFromDisk(): void {
-    if (!CRON_FILE) return;
-    const onDisk = loadCrons();
-    const diskIds = new Set(onDisk.map((t) => t.id));
-
-    for (const id of [...tasks.keys()]) {
-      if (!diskIds.has(id)) {
-        stopTask(id);
-        tasks.delete(id);
-      }
-    }
-
-    for (const task of onDisk) {
-      // Validate before starting — same rules as add path
-      if (!task.task || typeof task.task !== "string" || !task.task.trim()) continue;
-      if (task.intervalMs !== undefined && task.intervalMs < 10000) continue;
-
-      const existing = tasks.get(task.id);
-      if (!existing) {
-        if (task.id >= state.nextId) state.nextId = task.id + 1;
-        tasks.set(task.id, task);
-        startTask(task);
-        continue;
-      }
-      // Refresh mutable fields from disk without restarting timer unless schedule changed
-      const scheduleChanged =
-        existing.intervalMs !== task.intervalMs ||
-        existing.atHour !== task.atHour ||
-        existing.atMinute !== task.atMinute;
-      Object.assign(existing, task);
-      if (scheduleChanged) startTask(existing);
-    }
-    updateCronStatus();
+  function add(scope: CronScope, details: any) {
+    if (scope !== "session" && scope !== "project") throw new Error("scope must be session or project");
+    if (durable(scope) && !durableCronSupported()) throw new Error("Persistent cron scheduling is unavailable on this platform");
+    validateSchedule(details);
+    const task: CronTask = { id: randomUUID(), scope, cwd: ctx?.cwd || process.cwd(), description: details.description || details.task.slice(0, 60), task: details.task, intervalMs: details.interval_seconds !== undefined ? details.interval_seconds * 1000 : undefined, atHour: details.at_hour, atMinute: details.at_minute ?? (details.at_hour !== undefined ? 0 : undefined), createdAt: Date.now(), leader: scope === "session" };
+    if (!task.task || (!task.intervalMs && task.atHour === undefined)) throw new Error("task and a schedule are required");
+    if (durable(scope)) mutateDurableCronStore(projectStore(task.cwd), old => [...old, task as DurableCronTask]);
+    tasks.set(task.id, task);
+    // We may already own the relevant lock; schedule synchronously rather than waiting for fs.watch.
+    if (scope === "session" || owned.has(projectStore(task.cwd))) { task.leader = true; start(task); }
+    else election();
+    if (scope === "session") persist(task);
+    updateStatus(); log.info("cron_created", { scope, id: qualifyCronId(task) }); return task;
   }
-
-  let cronFileWatcher: fs.FSWatcher | null = null;
-
-  // Restore persisted crons on session start
-  pi.on("session_start", (_event, ctx) => {
-    state.lastCwd = ctx.cwd;
-    state.lastCtx = ctx;
-    CRON_FILE = path.join(getProjectTmpDir(ctx.cwd), `cron-${SESSION_SUFFIX}.json`);
-    cleanupOrphanedCronFiles();
-    // Skip cron scheduling in one-shot modes
-    if (ctx.mode === "print" || ctx.mode === "json") return;
-
-    // Restore from persistence (after /reload or /new)
-    const restored = loadCrons();
-    for (const task of restored) {
-      if (!tasks.has(task.id)) {
-        if (task.id >= state.nextId) state.nextId = task.id + 1;
-        tasks.set(task.id, task);
-      }
-    }
-    // Restart all timers with fresh context
-    for (const task of tasks.values()) {
-      startTask(task);
-    }
-    updateCronStatus();
-
-    // Ensure file exists so we can watch peer list-all removes
-    if (!fs.existsSync(CRON_FILE)) saveCrons([...tasks.values()]);
-
-    // Watch own file so /cron list-all remove from another session stops our timers
-    try {
-      cronFileWatcher?.close();
-    } catch { /* ignore */ }
-    cronFileWatcher = null;
-    try {
-      let debounce: ReturnType<typeof setTimeout> | null = null;
-      cronFileWatcher = fs.watch(CRON_FILE, () => {
-        if (Date.now() < CRON_IGNORE_WATCH_UNTIL) return;
-        if (debounce) clearTimeout(debounce);
-        debounce = setTimeout(() => {
-          if (Date.now() < CRON_IGNORE_WATCH_UNTIL) return;
-          try {
-            syncTasksFromDisk();
-          } catch (e: any) {
-            log.debug("sync from disk failed:", e?.message || e);
-          }
-        }, 150);
-      });
-      cronFileWatcher.unref?.();
-    } catch (e: any) {
-      log.debug("watch setup failed:", e?.message || e);
+  function remove(qualified: string) {
+    const [kind, id] = qualified.split(":", 2); const scope = kind === "persist" ? "project" : kind as CronScope; if (!id || !["session", "project"].includes(scope)) return false;
+    const task = tasks.get(id); if (scope === "session") { if (!task) return false; stop(id); tasks.delete(id); if (sessionStore) writeSessionTasks(sessionStore, [...tasks.values()].filter(t => t.scope === "session")); } else { const file = projectStore(ctx.cwd); let found = false; mutateDurableCronStore(file, old => { found = old.some(t => t.id === id); return old.filter(t => t.id !== id); }); if (!found) return false; if (task) { stop(id); tasks.delete(id); } }
+    updateStatus(); return true;
+  }
+  pi.registerTool({ name: "cron_manage", description: "Manage scheduled tasks. Set persist=true to keep a task across Pi sessions in this project.", parameters: Type.Object({ action: Type.Union([Type.Literal("add"), Type.Literal("list"), Type.Literal("remove")]), persist: Type.Optional(Type.Boolean()), description: Type.Optional(Type.String()), task: Type.Optional(Type.String()), interval_seconds: Type.Optional(Type.Number()), at_hour: Type.Optional(Type.Number()), at_minute: Type.Optional(Type.Number()), id: Type.Optional(Type.String()) }), async execute(_id, params: any) {
+    const scope: CronScope = params.persist ? "project" : "session";
+    try { if (params.action === "add" && (ctx?.mode === "print" || ctx?.mode === "json")) return { content: [{ type: "text", text: "Error: Cron scheduling is unavailable in one-shot mode." }] }; if (params.action === "add") { const task = add(scope, params); return { content: [{ type: "text", text: `Cron ${qualifyCronId(task)} created: ${formatCronSchedule(task)} → ${task.description}` }] }; } if (params.action === "remove") return { content: [{ type: "text", text: remove(params.id || "") ? "Cron removed." : "Task not found." }] }; const selected = [...tasks.values()].filter(t => !params.persist || t.scope === "project"); return { content: [{ type: "text", text: selected.length ? selected.map(t => `${qualifyCronId(t)} | ${formatCronSchedule(t)} | ${t.description} | ${t.leader === false ? "waiting for leader" : "active"}`).join("\n") : "No scheduled tasks." }] }; } catch (error: any) { return { content: [{ type: "text", text: `Error: ${error.message}` }] }; }
+  }, } as any);
+  pi.registerCommand("cron", { description: "Schedule tasks: add, list, list-all, remove; use --persist to keep a cron", handler: async (args, commandCtx) => { ctx = commandCtx; const parsed = parseCronScope((args || "").trim().split(/\s+/).filter(Boolean)); if (parsed.error) { ctx.ui?.notify(parsed.error, "warning"); return; } const [sub, ...rest] = parsed.rest; if (sub === "list" || sub === "list-all") { const showAll = sub === "list-all"; if (ctx.hasUI) await openCronStatusOverlay(ctx, { title: showAll ? "All cron tasks" : "Cron tasks", listTasks: () => [...tasks.values()].filter(t => showAll || !args.includes("--persist") || t.scope === "project").map(t => toCronStatusTaskView(t, { overlayId: qualifyCronId(t), isLocal: t.scope === "session", sessionLabel: t.leader === false ? `${t.scope} (waiting for leader)` : t.scope })), removeTask: remove }); return; } if (["remove", "rm", "delete"].includes(sub) && rest[0]) { ctx.ui?.notify(remove(rest[0]) ? "Cron removed." : "Task not found.", "info"); return; } pi.sendUserMessage(`Schedule this cron request using cron_manage. Set persist to ${parsed.scope === "project"}. Use persistence only when the user requests it. User request: "${parsed.rest.join(" ")}"`, { deliverAs: "followUp" }); }});
+  pi.events.on("pidash:cron-kill", (target: unknown) => {
+    if (target !== "all") { if (typeof target === "string") remove(target); return; }
+    const byStore = new Map<string, Set<string>>();
+    for (const task of tasks.values()) if (durable(task.scope)) {
+      const file = projectStore(task.cwd);
+      const ids = byStore.get(file) || new Set<string>(); ids.add(task.id); byStore.set(file, ids);
     }
+    for (const [file, ids] of byStore) mutateDurableCronStore(file, old => old.filter(task => !ids.has(task.id)));
+    for (const id of [...timers.keys()]) stop(id);
+    tasks.clear();
+    if (sessionStore) writeSessionTasks(sessionStore, []);
+    updateStatus();
   });
-
-  // Handle cron kill from pidash browser
-  pi.events.on("pidash:cron-kill", (data: unknown) => {
-    const target = data as string;
-    if (target === "all") {
-      for (const id of [...tasks.keys()]) {
-        stopTask(id);
-        tasks.delete(id);
-      }
-    } else {
-      const id = parseInt(target, 10);
-      if (id && tasks.has(id)) {
-        stopTask(id);
-        tasks.delete(id);
-      }
+  pi.on("session_start", (_event, newCtx) => {
+    cleanupRuntime(); tasks.clear(); ctx = newCtx; sessionStore = sessionStoreFor(ctx);
+    if (ctx.mode === "print" || ctx.mode === "json") return;
+    for (const raw of readSessionTasks(sessionStore)) {
+      try { validateSessionCronTask(raw); tasks.set(raw.id, { ...raw, scope: "session", cwd: ctx.cwd, leader: true }); }
+      catch (error: any) { log.error("invalid session cron ignored", error?.message || error); }
+    }
+    const projectCronCount = readDurableCronStore(projectStore(ctx.cwd)).tasks.length;
+    const trusted = typeof ctx.isProjectTrusted !== "function" || ctx.isProjectTrusted() === true;
+    for (const task of [...tasks.values()]) start(task);
+    if (trusted) {
+      for (const store of stores()) { fs.mkdirSync(path.dirname(store.file), { recursive: true, mode: 0o700 }); try { const w = fs.watch(path.dirname(store.file), () => election()); w.unref?.(); watchers.push(w); } catch (e: any) { log.warn("cron_watch_failed", { code: e?.code }); } }
+      election();
+      health = setInterval(() => { try { election(); } catch (error: any) { log.error("cron_election_failed", error?.message || error); } }, 10_000); health.unref?.();
+    } else syncStore("project", projectStore(ctx.cwd));
+    if (projectCronCount > 0 && ctx.hasUI) {
+      const leader = trusted && owned.has(projectStore(ctx.cwd));
+      ctx.ui.notify(`Loaded ${projectCronCount} project cron${projectCronCount === 1 ? "" : "s"} (${leader ? "executing" : trusted ? "waiting for leader" : "untrusted"}).`, "info");
+      log.info("project_crons_loaded", { count: projectCronCount, leader, trusted });
     }
-    saveCrons([...tasks.values()]);
-    updateCronStatus();
   });
-
-  // Stop all timers and persist on shutdown
-  pi.on("session_shutdown", () => {
-    try {
-      cronFileWatcher?.close();
-    } catch { /* ignore */ }
-    cronFileWatcher = null;
-    for (const id of timers.keys()) {
-      stopTask(id);
+  pi.on("session_shutdown", (event: any) => {
+    cleanupRuntime();
+    if (["new", "fork", "quit"].includes(event?.reason) && sessionStore) {
+      try { fs.unlinkSync(sessionStore); } catch (error: any) { if (error?.code !== "ENOENT") log.warn("cron session cleanup failed", error?.message || error); }
     }
-    saveCrons([...tasks.values()]);
   });
-
-  // Register cron_manage tool — the AI calls this with structured params
-  registerCronTool(pi, state);
-
-  // /cron command
-  registerCronCommand(pi, state);
-
-  return {
-    getCronTasks: () => [...tasks.values()],
-  };
+  return { getCronTasks: () => [...tasks.values()] };
 }