@cydm/pie 2.7.13 → 2.7.15

package/dist/builtin/extensions/cron/index.js

@@ -0,0 +1,669 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  Type
+} from "../../../chunks/chunk-XXGYUYXI.js";
+import "../../../chunks/chunk-LZQXQOPJ.js";
+
+// builtin/extensions/cron/index.ts
+import * as path4 from "node:path";
+import * as fs3 from "node:fs";
+import { homedir } from "node:os";
+
+// builtin/extensions/cron/store.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+
+// builtin/extensions/cron/schedule.ts
+var MINUTE = 6e4;
+function fields(expression) {
+  const parts = expression.trim().split(/\s+/);
+  if (parts.length !== 5) throw new Error("cron requires five numeric UTC fields");
+  return parts.map((part, i) => {
+    const [min, max] = [[0, 59], [0, 23], [1, 31], [1, 12], [0, 6]][i];
+    const values = /* @__PURE__ */ new Set();
+    for (const item of part.split(",")) {
+      if (!/^(\*|\d+(?:-\d+)?)(?:\/\d+)?$/.test(item)) throw new Error("invalid cron field");
+      const [range, stepText] = item.split("/");
+      const step = stepText === void 0 ? 1 : Number(stepText);
+      const ends = range === "*" ? [min, max] : range.split("-").map(Number);
+      const a = ends[0], b = ends[1] ?? (stepText === void 0 ? a : max);
+      if (a < min || b > max || a > b || step < 1 || step > max + 1) throw new Error("cron field out of bounds");
+      for (let n = a; n <= b; n += step) values.add(n);
+    }
+    return values;
+  });
+}
+function validateSchedule(value) {
+  if (!value || typeof value !== "object" || Object.keys(value).length !== 1) throw new Error("provide exactly one of at, every, cron");
+  const s = value;
+  if ("at" in s && typeof s.at === "string") {
+    const m = s.at.match(/^(\d{4})-(\d\d)-(\d\d)T(\d\d):(\d\d)(?::(\d\d)(?:\.\d{1,3})?)?(?:Z|[+-]\d\d:\d\d)$/);
+    if (m && +m[1] >= 1970 && +m[2] >= 1 && +m[2] <= 12 && +m[3] >= 1 && +m[3] <= new Date(Date.UTC(+m[1], +m[2], 0)).getUTCDate() && +m[4] < 24 && +m[5] < 60 && +(m[6] ?? 0) < 60 && Number.isFinite(Date.parse(s.at))) return s;
+  }
+  if ("every" in s && Number.isSafeInteger(s.every) && s.every >= 60 && s.every <= 31536e3) return s;
+  if ("cron" in s && typeof s.cron === "string" && s.cron.length <= 256) {
+    fields(s.cron);
+    return s;
+  }
+  throw new Error("invalid schedule (every: integer seconds 60..31536000; at: ISO timestamp with timezone)");
+}
+function nextTime(s, after) {
+  if ("at" in s) return Date.parse(s.at) > after ? Date.parse(s.at) : null;
+  if ("every" in s) return after + s.every * 1e3;
+  const f = fields(s.cron), parts = s.cron.trim().split(/\s+/);
+  const end = after + 8 * 366 * 864e5;
+  for (let t = Math.floor(after / MINUTE) * MINUTE + MINUTE; t <= end; t += MINUTE) {
+    const d = new Date(t);
+    if (!f[3].has(d.getUTCMonth() + 1) || !f[1].has(d.getUTCHours()) || !f[0].has(d.getUTCMinutes())) continue;
+    const dom = f[2].has(d.getUTCDate()), dow = f[4].has(d.getUTCDay());
+    if (parts[2] !== "*" && parts[4] !== "*" ? dom || dow : dom && dow) return t;
+  }
+  throw new Error("cron has no occurrence within eight years");
+}
+
+// builtin/extensions/cron/store.ts
+var Store = class {
+  constructor(dir) {
+    this.dir = dir;
+    fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  dir;
+  transaction(fn) {
+    const lock = path.join(this.dir, "write.lock");
+    fs.mkdirSync(lock, { mode: 448 });
+    try {
+      const state = this.read();
+      const result = fn(state);
+      this.save(state);
+      return result;
+    } finally {
+      fs.rmdirSync(lock);
+    }
+  }
+  read() {
+    const file = path.join(this.dir, "state.json");
+    if (!fs.existsSync(file)) return { version: 1, jobs: [], owners: {} };
+    if (fs.statSync(file).size > 4e6) throw new Error("cron state exceeds size limit");
+    const s = JSON.parse(fs.readFileSync(file, "utf8"));
+    if (s.version !== 1 || !Array.isArray(s.jobs) || !s.owners || typeof s.owners !== "object") throw new Error("invalid cron state; manual recovery required");
+    if (Array.isArray(s.owners) || s.jobs.length > 100 || Object.keys(s.owners).length > 1e3) throw new Error("cron state exceeds record limit");
+    const ids = /* @__PURE__ */ new Set();
+    for (const j of s.jobs) {
+      if (!j || typeof j.id !== "string" || ids.has(j.id) || typeof j.sessionId !== "string" || !j.sessionId || j.sessionId.length > 256 || typeof j.cwd !== "string" || !path.isAbsolute(j.cwd) || typeof j.prompt !== "string" || !j.prompt.trim() || j.prompt.length > 16e3 || typeof j.enabled !== "boolean" || !["ready", "running", "blocked"].includes(j.state) || j.next !== null && !Number.isSafeInteger(j.next)) throw new Error("invalid cron job; manual recovery required");
+      ids.add(j.id);
+      validateSchedule(j.schedule);
+    }
+    for (const o of Object.values(s.owners)) {
+      if (!o || o.sessionId !== null && typeof o.sessionId !== "string" || typeof o.cwd !== "string" || !path.isAbsolute(o.cwd) || typeof o.busy !== "boolean") throw new Error("invalid cron owner; manual recovery required");
+    }
+    return s;
+  }
+  save(state) {
+    const content = JSON.stringify(state, null, 2);
+    const projected = {
+      ...state,
+      owners: Object.fromEntries(Object.entries(state.owners).map(([id, owner]) => [id, { ...owner, busy: false }])),
+      jobs: state.jobs.map((job) => ({
+        ...job,
+        enabled: false,
+        state: "blocked",
+        next: -Number.MAX_SAFE_INTEGER,
+        occurrence: -Number.MAX_SAFE_INTEGER,
+        target: "x".repeat(64),
+        deliveryStarted: false,
+        error: "
".repeat(500)
+      }))
+    };
+    if (state.jobs.length > 100 || Object.keys(state.owners).length > 1e3 || Buffer.byteLength(content, "utf8") > 4e6 || Buffer.byteLength(JSON.stringify(projected, null, 2), "utf8") > 4e6) throw new Error("cron state exceeds storage budget; no changes saved");
+    const temp = path.join(this.dir, `state.${randomUUID()}.tmp`), dest = path.join(this.dir, "state.json");
+    const fd = fs.openSync(temp, "wx", 384);
+    try {
+      fs.writeFileSync(fd, content);
+      fs.fsyncSync(fd);
+    } finally {
+      fs.closeSync(fd);
+    }
+    fs.renameSync(temp, dest);
+    if (process.platform !== "win32") {
+      const dir = fs.openSync(this.dir, "r");
+      try {
+        fs.fsyncSync(dir);
+      } finally {
+        fs.closeSync(dir);
+      }
+    }
+  }
+  add(sessionId, cwd, prompt, schedule, now = Date.now()) {
+    if (!sessionId || sessionId.length > 256) throw new Error("an existing session is required");
+    if (typeof prompt !== "string" || !prompt.trim() || prompt.length > 16e3) throw new Error("prompt must contain 1..16000 characters");
+    const validated = validateSchedule(schedule), next = nextTime(validated, now);
+    if (next === null) throw new Error("at must be in the future");
+    const job = { id: randomUUID(), sessionId, cwd: fs.realpathSync(cwd), prompt, schedule: validated, enabled: true, next, state: "ready" };
+    return this.transaction((s) => {
+      if (s.jobs.length >= 100) throw new Error("maximum 100 jobs");
+      s.jobs.push(job);
+      return job;
+    });
+  }
+  change(id, action, now = Date.now()) {
+    this.transaction((s) => {
+      const j = s.jobs.find((j2) => j2.id === id);
+      if (!j) throw new Error("unknown job");
+      if (j.state === "running") throw new Error("job is running; wait for completion or recover offline");
+      if (action === "remove") {
+        s.jobs = s.jobs.filter((j2) => j2.id !== id);
+        return;
+      }
+      j.enabled = action === "resume";
+      if (j.enabled) {
+        j.next = nextTime(j.schedule, Math.max(now, j.occurrence ?? now));
+        if (j.next === null) throw new Error("one-shot expired; create a new job");
+        j.state = "ready";
+        delete j.error;
+      }
+    });
+  }
+};
+function complete(job, error, now = Date.now()) {
+  delete job.target;
+  delete job.deliveryStarted;
+  if (error) {
+    job.state = "blocked";
+    job.error = error.slice(0, 500);
+    return;
+  }
+  job.state = "ready";
+  delete job.error;
+  job.next = "at" in job.schedule ? null : nextTime(job.schedule, Math.max(now, job.occurrence ?? now));
+  if (job.next === null) job.enabled = false;
+}
+
+// builtin/extensions/cron/runtime.ts
+import * as fs2 from "node:fs";
+import * as path3 from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
+
+// builtin/extensions/cron/worker.ts
+import { spawn } from "node:child_process";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import * as path2 from "node:path";
+import { StringDecoder } from "node:string_decoder";
+function runWorker(job, signal, cli = process.argv[1], configDir) {
+  if (signal.aborted) return Promise.reject(new Error("worker interrupted before launch"));
+  return new Promise((resolve3, reject) => {
+    const child = spawn(process.execPath, [path2.resolve(cli), "--json-events", "--session-id", job.sessionId, "--resume-required"], {
+      cwd: job.cwd,
+      env: { ...process.env, ...configDir ? { PIE_CODING_AGENT_DIR: configDir } : {}, PIE_CRON_ROLE: "worker" },
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true
+    });
+    const decoder = new StringDecoder("utf8");
+    const turnId = randomUUID2();
+    let buffer = "", settled = false, sent = false, completed = false;
+    let failure;
+    let killTimer;
+    const stop = () => {
+      failure ??= "worker interrupted; outcome uncertain";
+      child.kill();
+      killTimer ??= setTimeout(() => child.kill("SIGKILL"), 5e3);
+      killTimer.unref();
+    };
+    const protocolError = (message) => {
+      failure = message;
+      stop();
+    };
+    signal.addEventListener("abort", stop, { once: true });
+    const timer = setTimeout(stop, 15 * 6e4);
+    timer.unref();
+    child.stdin.on("error", () => {
+    });
+    child.stderr.resume();
+    child.stdout.on("data", (chunk) => {
+      buffer += decoder.write(chunk);
+      if (buffer.length > 2e6) {
+        protocolError("oversized worker event; outcome uncertain");
+        return;
+      }
+      let index;
+      while ((index = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, index);
+        buffer = buffer.slice(index + 1);
+        try {
+          const event = JSON.parse(line);
+          if (!event || typeof event.type !== "string") throw new Error("invalid event");
+          if (event.type === "agent.ready") {
+            if (sent || event.sessionId !== job.sessionId) {
+              protocolError("worker readiness/session mismatch");
+              return;
+            }
+            sent = true;
+            child.stdin.write(JSON.stringify({ type: "turn.request", sessionId: job.sessionId, turnId, prompt: job.prompt }) + "\n");
+          }
+          if (["turn.completed", "turn.failed", "turn.cancelled", "turn.stalled", "turn.settled"].includes(event.type)) {
+            if (!sent || event.sessionId !== job.sessionId || event.turnId !== turnId || settled) {
+              protocolError("worker turn identity/order mismatch");
+              return;
+            }
+            if (event.type === "turn.completed") {
+              if (completed) {
+                protocolError("duplicate worker completion");
+                return;
+              }
+              completed = true;
+            } else if (event.type === "turn.settled") {
+              if (!completed) {
+                protocolError("worker settled without completion");
+                return;
+              }
+              settled = true;
+              child.stdin.end(JSON.stringify({ type: "shutdown" }) + "\n");
+            } else {
+              protocolError(`worker ${event.type}`);
+              return;
+            }
+          }
+          if (event.type === "error") {
+            protocolError("worker protocol error; inspect session before resuming");
+            return;
+          }
+        } catch {
+          protocolError("invalid worker output");
+          return;
+        }
+      }
+    });
+    child.on("error", (error) => {
+      failure = error.message;
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      clearTimeout(killTimer);
+      signal.removeEventListener("abort", stop);
+      buffer += decoder.end();
+      if (buffer.trim()) failure ??= "truncated worker event; outcome uncertain";
+      if (failure || !settled || !completed || code !== 0) reject(new Error(failure ?? `worker exited ${code}; outcome uncertain`));
+      else resolve3();
+    });
+    if (signal.aborted) stop();
+  });
+}
+
+// builtin/extensions/cron/runtime.ts
+var delay = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
+var isContention = (error) => error?.code === "EEXIST";
+var Runtime = class {
+  constructor(ctx, store, execute = runWorker) {
+    this.ctx = ctx;
+    this.store = store;
+    this.execute = execute;
+    this.cwd = fs2.realpathSync(ctx.cwd);
+  }
+  ctx;
+  store;
+  execute;
+  id = randomUUID3();
+  sessionId = null;
+  leader = false;
+  recovering = false;
+  stopped = false;
+  initialized = false;
+  binding = 0;
+  polling = false;
+  timer;
+  abort = new AbortController();
+  worker;
+  cwd;
+  notices = /* @__PURE__ */ new Set();
+  completions = /* @__PURE__ */ new Map();
+  accepted;
+  get ready() {
+    return this.initialized && !this.stopped;
+  }
+  get generation() {
+    return this.binding;
+  }
+  onStart() {
+    if (this.accepted?.consumed) this.accepted.busy = true;
+  }
+  onMessage(message) {
+    if (!this.accepted || message.role !== "user") return;
+    const text = typeof message.content === "string" ? message.content : message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+    if (text.includes(this.accepted.content)) {
+      this.accepted.consumed = true;
+      this.accepted.busy = true;
+    }
+  }
+  onFailure() {
+    if (this.accepted?.consumed) this.accepted.error = "interactive turn failed or cancelled; inspect before resuming";
+  }
+  start() {
+    this.initialized = false;
+    this.timer = setInterval(() => void this.poll(), 1e3);
+    this.timer.unref();
+  }
+  markUnsafe() {
+    fs2.mkdirSync(path3.join(this.store.dir, "unsafe.lock"), { recursive: true, mode: 448 });
+  }
+  persistOwner(sessionId) {
+    this.store.transaction((state) => {
+      state.owners[this.id] = { sessionId, cwd: this.cwd, busy: !this.ctx.isIdle() };
+    });
+    this.sessionId = sessionId;
+    this.initialized = true;
+  }
+  register(sessionId) {
+    try {
+      this.persistOwner(sessionId);
+    } catch (error) {
+      this.markUnsafe();
+      throw error;
+    }
+  }
+  async bind(sessionId) {
+    const generation = ++this.binding;
+    this.initialized = false;
+    for (let attempt = 0; attempt < 20; attempt++) {
+      if (this.stopped || generation !== this.binding) return;
+      try {
+        this.persistOwner(sessionId);
+        return;
+      } catch (error) {
+        if (!isContention(error)) break;
+        await delay(25 + Math.floor(Math.random() * 25));
+      }
+    }
+    if (!this.stopped && generation === this.binding) this.register(sessionId);
+  }
+  notify(job) {
+    if (job.sessionId !== this.sessionId || !job.error) return;
+    const key = job.id + job.error;
+    if (!this.notices.has(key)) {
+      this.notices.add(key);
+      this.ctx.ui.notify(`cron ${job.id}: ${job.error}`, "warning");
+    }
+  }
+  flushCompletions() {
+    for (const [id, error] of this.completions) {
+      try {
+        this.store.transaction((state) => {
+          const job = state.jobs.find((item) => item.id === id);
+          if (job?.state === "running") complete(job, error);
+        });
+        this.completions.delete(id);
+      } catch (failure) {
+        if (!isContention(failure)) this.markUnsafe();
+        return;
+      }
+    }
+  }
+  finish(id, error) {
+    this.completions.set(id, error);
+    this.flushCompletions();
+  }
+  async poll(now = Date.now()) {
+    if (this.stopped || this.polling || !this.initialized) return;
+    if (fs2.existsSync(path3.join(this.store.dir, "unsafe.lock"))) {
+      this.abort.abort();
+      this.ctx.ui.setStatus?.("cron", void 0);
+      return;
+    }
+    this.polling = true;
+    try {
+      this.flushCompletions();
+      if (this.completions.size) return;
+      if (!this.leader) {
+        try {
+          fs2.mkdirSync(path3.join(this.store.dir, "scheduler.lock"), { mode: 448 });
+          this.leader = true;
+          this.recovering = true;
+        } catch (error) {
+          if (!isContention(error)) throw error;
+        }
+      }
+      let delivery, launch;
+      this.store.transaction((state2) => {
+        if (this.recovering) {
+          for (const job of state2.jobs) {
+            if (job.state === "running" && (job.target === "worker" || !job.target || !state2.owners[job.target])) {
+              complete(job, "coordinator restarted; outcome uncertain");
+            }
+          }
+        }
+        state2.owners[this.id] = { sessionId: this.sessionId, cwd: this.cwd, busy: !this.ctx.isIdle() };
+        for (const job of state2.jobs) {
+          const owners = Object.entries(state2.owners).filter(([, owner]) => owner.sessionId === job.sessionId);
+          if (this.leader && job.state === "running" && job.target === "worker" && owners.length) this.abort.abort();
+          if (job.enabled && owners.length > 1 && job.state !== "running") complete(job, "duplicate participating session owners; close duplicate and resume job");
+          if (job.state === "running" && job.target === this.id && this.accepted?.id === job.id) {
+            if (!this.accepted.consumed) {
+              for (const message of this.ctx.getMessages?.() ?? []) this.onMessage(message);
+            }
+            if (owners.length !== 1 || this.sessionId !== job.sessionId) {
+              complete(job, "owner changed or duplicate during delivery");
+              this.accepted = void 0;
+            } else if (this.accepted.consumed && this.accepted.busy && this.ctx.isIdle()) {
+              complete(job, this.accepted.error);
+              this.accepted = void 0;
+            } else if (!this.accepted.consumed && now - this.accepted.at > 6e4) {
+              complete(job, "input accepted but execution not observed; inspect before resuming");
+              this.accepted = void 0;
+            }
+          }
+          if (job.state === "running" && job.target === this.id && !job.deliveryStarted && this.ctx.isIdle()) {
+            if (owners.length !== 1 || owners[0][0] !== this.id || this.sessionId !== job.sessionId || this.cwd !== job.cwd) {
+              complete(job, "owner changed or duplicate; delivery blocked");
+            } else {
+              job.deliveryStarted = true;
+              delivery = { ...job };
+            }
+          }
+        }
+        if (this.leader && !state2.jobs.some((job) => job.state === "running")) {
+          const due = state2.jobs.filter((job) => job.enabled && job.state === "ready" && job.next !== null && job.next <= now).sort((a, b) => a.next - b.next);
+          for (const job of due) {
+            if (state2.jobs.some((other) => other.enabled && other.sessionId === job.sessionId && other.state === "blocked")) continue;
+            const owners = Object.entries(state2.owners).filter(([, owner]) => owner.sessionId === job.sessionId);
+            if (owners.length > 1) {
+              complete(job, "duplicate participating session owners");
+              continue;
+            }
+            if (owners.length === 1 && owners[0][1].cwd !== job.cwd) {
+              complete(job, "owner cwd differs from bound cwd");
+              continue;
+            }
+            if (owners[0]?.[1].busy) continue;
+            job.state = "running";
+            job.occurrence = job.next;
+            job.target = owners[0]?.[0] ?? "worker";
+            if (job.target === "worker") launch = { ...job };
+            break;
+          }
+        }
+      });
+      this.recovering = false;
+      if (delivery) {
+        const job = delivery;
+        const scope = this.ctx.beginUserInput?.(() => !this.stopped && this.ready && this.sessionId === job.sessionId && !fs2.existsSync(path3.join(this.store.dir, "unsafe.lock")) && Object.values(this.store.read().owners).filter((owner) => owner.sessionId === job.sessionId).length === 1);
+        let error;
+        const content = `[Cron job=${job.id} scheduledAt=${job.occurrence}]
+${job.prompt}`;
+        this.accepted = { id: job.id, at: now, busy: false, consumed: false, content };
+        try {
+          if (!scope || !await scope.submit(content)) error = "input rejected or session changed; inspect before resuming";
+        } catch (failure) {
+          error = `input outcome uncertain: ${String(failure)}`;
+        } finally {
+          scope?.dispose();
+        }
+        if (error) {
+          this.accepted = void 0;
+          this.finish(job.id, error);
+        }
+      }
+      if (launch) {
+        const job = launch;
+        const latest = this.store.read();
+        if (this.stopped || fs2.existsSync(path3.join(this.store.dir, "unsafe.lock")) || Object.values(latest.owners).some((owner) => owner.sessionId === job.sessionId)) {
+          this.finish(job.id, "ownership changed before worker launch; inspect before resuming");
+          return;
+        }
+        this.abort = new AbortController();
+        this.worker = this.execute(job, this.abort.signal, void 0, path3.dirname(this.store.dir)).then(() => this.finish(job.id), (error) => this.finish(job.id, String(error))).catch(() => {
+          try {
+            this.markUnsafe();
+          } catch {
+          }
+        });
+      }
+      const state = this.store.read(), enabled = state.jobs.filter((job) => job.enabled);
+      this.ctx.ui.setStatus?.("cron", this.leader && enabled.some((job) => job.sessionId === this.sessionId) ? `cron: ${enabled.length} enabled, ${enabled.filter((job) => job.state === "blocked").length} blocked` : void 0);
+      for (const job of state.jobs) this.notify(job);
+    } catch {
+      this.ctx.ui.setStatus?.("cron", void 0);
+    } finally {
+      this.polling = false;
+    }
+  }
+  async stop() {
+    this.stopped = true;
+    clearInterval(this.timer);
+    this.abort.abort();
+    await this.worker;
+    while (this.polling) await delay(10);
+    for (let attempt = 0; ; attempt++) {
+      try {
+        this.store.transaction((state) => {
+          for (const [id, error] of this.completions) {
+            const job = state.jobs.find((item) => item.id === id);
+            if (job?.state === "running") complete(job, error);
+          }
+          delete state.owners[this.id];
+          for (const job of state.jobs) {
+            if (job.state === "running" && job.target === this.id) complete(job, "owner closed before delivery; inspect before resuming");
+          }
+        });
+        this.completions.clear();
+        break;
+      } catch (error) {
+        if (!isContention(error) || attempt >= 39) throw error;
+        await delay(25 + Math.floor(Math.random() * 25));
+      }
+    }
+    if (this.leader) {
+      fs2.rmdirSync(path3.join(this.store.dir, "scheduler.lock"));
+      this.leader = false;
+    }
+    this.ctx.ui.setStatus?.("cron", void 0);
+  }
+};
+
+// builtin/extensions/cron/index.ts
+function configPath() {
+  const env = process.env.PIE_CODING_AGENT_DIR;
+  return path4.resolve(env === "~" ? homedir() : env?.startsWith("~/") ? path4.join(homedir(), env.slice(2)) : env || path4.join(homedir(), ".pie"));
+}
+function cron(ctx) {
+  if (process.env.PIE_CRON_ROLE === "worker" || !ctx.hasUI) return;
+  const store = new Store(path4.join(configPath(), "cron"));
+  const runtime = new Runtime(ctx, store);
+  let startupError;
+  try {
+    runtime.start();
+  } catch (e) {
+    startupError = String(e);
+  }
+  ctx.registerCleanup?.(() => runtime.stop());
+  ctx.on("agent:start", () => runtime.onStart());
+  ctx.on("message:end", (e) => runtime.onMessage(e.message));
+  ctx.on("turn:failed", () => runtime.onFailure());
+  ctx.on("turn:cancelled", () => runtime.onFailure());
+  ctx.on("session:changed", async (e) => {
+    try {
+      await runtime.bind(e.sessionId);
+    } catch (e2) {
+      startupError = String(e2);
+    }
+  });
+  ctx.on("terminal:input", (e) => {
+    if (/^\/cron(?:\s|$)/.test(e.text)) return;
+    try {
+      const state = store.read();
+      if (!state.jobs.some((j) => j.sessionId === runtime.sessionId && (j.enabled || j.state === "running"))) return;
+      const duplicates = Object.values(state.owners).filter((o) => o.sessionId === runtime.sessionId).length > 1;
+      const worker = state.jobs.some((j) => j.sessionId === runtime.sessionId && j.state === "running" && j.target === "worker");
+      if (!startupError && runtime.ready && !duplicates && !worker && !fs3.existsSync(path4.join(store.dir, "unsafe.lock"))) return;
+    } catch {
+    }
+    ctx.ui.notify("cron: session ownership is uncertain or duplicated; input blocked. Close the duplicate/worker and inspect /cron.", "warning");
+    return { action: "consume" };
+  });
+  ctx.on("session:before_switch", (e) => {
+    if (!e.targetSessionId) return;
+    try {
+      const s = store.read();
+      const relevant = s.jobs.some((j) => j.sessionId === e.targetSessionId && (j.enabled || j.state === "running"));
+      if (relevant && (Object.entries(s.owners).some(([id, o]) => id !== runtime.id && o.sessionId === e.targetSessionId) || s.jobs.some((j) => j.sessionId === e.targetSessionId && j.state === "running"))) {
+        ctx.ui.notify("cron: target session is owned or has an uncertain occurrence. Switch cancelled.", "warning");
+        return { cancel: true };
+      }
+    } catch {
+      return { cancel: true };
+    }
+  });
+  const run = (action, id, prompt, schedule) => {
+    if (startupError) throw new Error(`cron unavailable: ${startupError}; see docs/cron.md recovery`);
+    if (action === "list") return JSON.stringify({ ...store.read(), recoveryRequired: fs3.existsSync(path4.join(store.dir, "unsafe.lock")), coordinatorPresent: fs3.existsSync(path4.join(store.dir, "scheduler.lock")) }, null, 2);
+    if (action === "add") {
+      if (!runtime.ready || !runtime.sessionId) throw new Error("wait for an existing session to load and register");
+      return JSON.stringify({
+        job: store.add(runtime.sessionId, ctx.cwd, prompt, schedule),
+        note: "Saved. The original session/cwd will be resumed automatically. Keep at least one cron-enabled Pie open; no execution while all are closed or the computer sleeps."
+      });
+    }
+    if (action === "pause" || action === "resume" || action === "remove") {
+      store.change(id ?? "", action);
+      return `${action}: ${id}`;
+    }
+    throw new Error('Usage: /cron list | add {"prompt":"...","schedule":{"every":3600}} | pause|resume|remove <id>');
+  };
+  ctx.registerCommand({ path: ["cron"], description: "Persistent same-session schedules (UTC): list/add/pause/resume/remove", handler: async (_ctx, args) => {
+    try {
+      const match = (args ?? "").trim().match(/^(\S+)(?:\s+([\s\S]*))?$/);
+      const action = match?.[1] ?? "list", rest = match?.[2];
+      const data = action === "add" ? JSON.parse(rest ?? "{}") : void 0;
+      ctx.ui.notify(run(action, rest, data?.prompt, data?.schedule), "info");
+    } catch (e) {
+      ctx.ui.notify(String(e), "warning");
+    }
+  } });
+  ctx.registerTool({
+    name: "cron_manage",
+    label: "Cron",
+    description: "Manage persistent scheduled prompts bound to THIS existing session and cwd. No new sessions. Actions list/add/pause/resume/remove. every is seconds (minimum 60), at is ISO with timezone, cron is five numeric UTC fields. Missed intervals coalesce; blocked/uncertain tasks require human review before resume.",
+    parameters: Type.Object({ action: Type.Union(["list", "add", "pause", "resume", "remove"].map((s) => Type.Literal(s))), id: Type.Optional(Type.String()), prompt: Type.Optional(Type.String({ maxLength: 16e3 })), schedule: Type.Optional(Type.Union([Type.Object({ at: Type.String() }), Type.Object({ every: Type.Integer({ minimum: 60, maximum: 31536e3 }) }), Type.Object({ cron: Type.String({ maxLength: 256 }) })])) }),
+    risk: { riskClass: "external_side_effect", permissionScope: "host", availableInPlanMode: false, requiresPermission: true, externalSideEffect: true, allowedForSubagentByDefault: false, concurrencySafe: false },
+    execute: async (args) => {
+      try {
+        if (args.action !== "list") {
+          const sessionId = runtime.sessionId, generation = runtime.generation;
+          if (!runtime.ready) throw new Error("session binding is in progress; no changes saved");
+          if (!ctx.interactions.isAvailable() || !await ctx.ui.confirm(
+            "Approve cron change",
+            JSON.stringify({ action: args.action, id: args.id, sessionId, cwd: ctx.cwd, prompt: args.prompt, schedule: args.schedule }) + "\nTasks persist and may execute later while any participating Pie is open, using saved configuration."
+          )) {
+            throw new Error("cron change was not approved; no changes saved");
+          }
+          if (!runtime.ready || generation !== runtime.generation || sessionId !== runtime.sessionId) throw new Error("session changed during approval; no changes saved");
+        }
+        return { content: [{ type: "text", text: run(args.action, args.id, args.prompt, args.schedule) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: String(e) }], isError: true };
+      }
+    }
+  });
+}
+export {
+  configPath,
+  cron as default
+};

package/dist/builtin/extensions/cron/package.json

@@ -0,0 +1,11 @@
+{
+	"name": "@pie/extension-cron",
+	"version": "1.0.0",
+	"description": "Cooperative persistent same-session CLI schedules",
+	"type": "module",
+	"main": "index.js",
+	"pie": {
+		"name": "cron",
+		"main": "index.js"
+	}
+}