@pasko70/pibo 1.9.9 → 1.9.11

package/dist/cron/cli.js

@@ -0,0 +1,230 @@
+import { Command } from "commander";
+import { parseFriendlySchedule } from "./schedule.js";
+import { createDefaultPiboCronStore } from "./store.js";
+function printDiscovery() {
+    console.log(`pibo cron
+
+Manage scheduled Pibo agent jobs.
+
+Commands:
+  status    Show scheduler store status
+  list      List cron jobs
+  add       Create a cron job
+  edit      Update a cron job
+  pause     Disable a cron job
+  resume    Enable a cron job and recompute next run
+  remove    Delete a cron job
+  runs      List cron runs
+
+Next: pibo cron add --help
+      pibo cron edit --help`);
+}
+function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+function targetFromOptions(options) {
+    if (options.room)
+        return { kind: "room", roomId: options.room };
+    if (options.defaultChat)
+        return { kind: "default-chat" };
+    throw new Error("Choose a target: --room <roomId> or --default-chat");
+}
+function maybeTargetFromOptions(options) {
+    if (!options.room && !options.defaultChat)
+        return undefined;
+    return targetFromOptions(options);
+}
+function hasScheduleOptions(options, positionalCron) {
+    return Boolean(positionalCron ||
+        typeof options.in === "string" ||
+        typeof options.at === "string" ||
+        typeof options.every === "string" ||
+        typeof options.daily === "string" ||
+        typeof options.weekly === "string" ||
+        typeof options.monthly === "string" ||
+        typeof options.monthly === "number" ||
+        typeof options.cron === "string");
+}
+function scheduleFromOptions(options, positionalCron) {
+    if (typeof options.in === "string")
+        return parseFriendlySchedule({ kind: "in", value: options.in });
+    if (typeof options.at === "string")
+        return parseFriendlySchedule({ kind: "at", value: options.at, tz: typeof options.tz === "string" ? options.tz : undefined });
+    if (typeof options.every === "string")
+        return parseFriendlySchedule({ kind: "every", value: options.every });
+    if (typeof options.daily === "string")
+        return parseFriendlySchedule({ kind: "daily", time: options.daily, tz: typeof options.tz === "string" ? options.tz : undefined });
+    if (typeof options.weekly === "string") {
+        const time = typeof options.time === "string" ? options.time : undefined;
+        if (!time)
+            throw new Error("--weekly requires --time HH:MM");
+        return parseFriendlySchedule({ kind: "weekly", weekdays: options.weekly, time, tz: typeof options.tz === "string" ? options.tz : undefined });
+    }
+    if (typeof options.monthly === "string" || typeof options.monthly === "number") {
+        const time = typeof options.time === "string" ? options.time : undefined;
+        if (!time)
+            throw new Error("--monthly requires --time HH:MM");
+        return parseFriendlySchedule({ kind: "monthly", dayOfMonth: Number(options.monthly), time, tz: typeof options.tz === "string" ? options.tz : undefined });
+    }
+    if (typeof options.cron === "string")
+        return parseFriendlySchedule({ kind: "cron", expr: options.cron, tz: typeof options.tz === "string" ? options.tz : undefined });
+    if (positionalCron)
+        return parseFriendlySchedule({ kind: "cron", expr: positionalCron, tz: typeof options.tz === "string" ? options.tz : undefined });
+    throw new Error("Choose a schedule: --in, --at, --every, --daily, --weekly, --monthly, --cron, or pass a quoted cron expression");
+}
+export async function runCronCli(argv = process.argv) {
+    if (argv.length <= 2 || argv[2] === "--help" || argv[2] === "-h") {
+        printDiscovery();
+        return;
+    }
+    const program = new Command();
+    program.name("pibo cron").description("Manage scheduled Pibo jobs").helpOption("-h, --help");
+    program.option("--store <path>", "Cron store path");
+    program.command("status").description("Show cron store status").option("--json", "Print JSON").action((options) => {
+        const store = createDefaultPiboCronStore({ path: program.opts().store });
+        const status = store.status();
+        if (options.json)
+            printJson(status);
+        else {
+            console.log(`jobs\t${status.jobs}`);
+            console.log(`running\t${status.running}`);
+            console.log(`nextRunAt\t${status.nextRunAt ?? "-"}`);
+        }
+        store.close();
+    });
+    program.command("list").description("List cron jobs").option("--all", "Include disabled jobs").option("--json", "Print JSON").action((options) => {
+        const store = createDefaultPiboCronStore({ path: program.opts().store });
+        const jobs = store.listJobs({ includeDisabled: options.all });
+        if (options.json)
+            printJson(jobs);
+        else
+            for (const job of jobs)
+                console.log(`${job.id}\t${job.enabled ? "enabled" : "disabled"}\t${job.state.nextRunAt ?? "-"}\t${job.name}`);
+        store.close();
+    });
+    program.command("add")
+        .description("Create a cron job")
+        .argument("[cronExpr...]", "Raw 5-field cron expression, e.g. \"0 8 * * *\"")
+        .option("--room <roomId>", "Target room")
+        .option("--default-chat", "Target the shared default chat")
+        .option("--agent <profile>", "Agent/profile", "base")
+        .option("--name <name>", "Job name")
+        .requiredOption("--prompt <text>", "Prompt/task")
+        .option("--in <duration>", "Run once after duration, e.g. 20m")
+        .option("--at <iso>", "Run once at ISO timestamp")
+        .option("--every <duration>", "Run every duration, e.g. 2h")
+        .option("--daily <HH:MM>", "Run daily at time")
+        .option("--weekly <days>", "Run weekly on comma-separated days")
+        .option("--monthly <day>", "Run monthly on day of month")
+        .option("--time <HH:MM>", "Time for weekly/monthly")
+        .option("--cron <expr>", "Raw 5-field cron expression")
+        .option("--tz <timezone>", "Timezone for wall-clock schedules")
+        .option("--disabled", "Create disabled")
+        .option("--delete-after-run", "Delete successful one-shot job")
+        .option("--json", "Print JSON")
+        .action((cronExprParts, options) => {
+        const store = createDefaultPiboCronStore({ path: program.opts().store });
+        const positionalCron = Array.isArray(cronExprParts) && cronExprParts.length ? cronExprParts.join(" ") : undefined;
+        const normalized = scheduleFromOptions(options, positionalCron);
+        const job = store.createJob({
+            name: options.name,
+            enabled: options.disabled ? false : true,
+            target: targetFromOptions(options),
+            profile: options.agent,
+            prompt: options.prompt,
+            schedule: normalized.schedule,
+            scheduleUi: normalized.scheduleUi,
+            deleteAfterRun: options.deleteAfterRun === true,
+        });
+        if (options.json)
+            printJson(job);
+        else
+            console.log(`${job.id}\t${job.state.nextRunAt ?? "-"}\t${job.name}`);
+        store.close();
+    });
+    program.command("edit")
+        .description("Update a cron job")
+        .argument("<id>", "Cron job id")
+        .argument("[cronExpr...]", "Raw 5-field cron expression, e.g. \"0 8 * * *\"")
+        .option("--room <roomId>", "Target room")
+        .option("--default-chat", "Target the shared default chat")
+        .option("--agent <profile>", "Agent/profile")
+        .option("--name <name>", "Job name")
+        .option("--description <text>", "Job description")
+        .option("--prompt <text>", "Prompt/task")
+        .option("--in <duration>", "Run once after duration, e.g. 20m")
+        .option("--at <iso>", "Run once at ISO timestamp")
+        .option("--every <duration>", "Run every duration, e.g. 2h")
+        .option("--daily <HH:MM>", "Run daily at time")
+        .option("--weekly <days>", "Run weekly on comma-separated days")
+        .option("--monthly <day>", "Run monthly on day of month")
+        .option("--time <HH:MM>", "Time for weekly/monthly")
+        .option("--cron <expr>", "Raw 5-field cron expression")
+        .option("--tz <timezone>", "Timezone for wall-clock schedules")
+        .option("--enabled", "Enable the job")
+        .option("--disabled", "Disable the job")
+        .option("--delete-after-run", "Delete successful one-shot job")
+        .option("--keep-after-run", "Keep job after successful one-shot run")
+        .option("--json", "Print JSON")
+        .action((id, cronExprParts, options) => {
+        const store = createDefaultPiboCronStore({ path: program.opts().store });
+        const positionalCron = Array.isArray(cronExprParts) && cronExprParts.length ? cronExprParts.join(" ") : undefined;
+        const normalized = hasScheduleOptions(options, positionalCron) ? scheduleFromOptions(options, positionalCron) : undefined;
+        const target = maybeTargetFromOptions(options);
+        const patch = {
+            ...(options.name !== undefined ? { name: options.name } : {}),
+            ...(options.description !== undefined ? { description: options.description } : {}),
+            ...(options.agent !== undefined ? { profile: options.agent } : {}),
+            ...(options.prompt !== undefined ? { prompt: options.prompt } : {}),
+            ...(target ? { target } : {}),
+            ...(normalized ? { schedule: normalized.schedule, scheduleUi: normalized.scheduleUi } : {}),
+            ...(options.enabled === true ? { enabled: true } : {}),
+            ...(options.disabled === true ? { enabled: false } : {}),
+            ...(options.deleteAfterRun === true ? { deleteAfterRun: true } : {}),
+            ...(options.keepAfterRun === true ? { deleteAfterRun: false } : {}),
+        };
+        if (Object.keys(patch).length === 0)
+            throw new Error("No cron job update fields provided");
+        const job = store.updateJob(id, patch);
+        if (!job)
+            throw new Error("Cron job not found");
+        if (options.json)
+            printJson(job);
+        else
+            console.log(`${job.id}\t${job.enabled ? "enabled" : "disabled"}\t${job.state.nextRunAt ?? "-"}\t${job.name}`);
+        store.close();
+    });
+    for (const [name, enabled] of [["pause", false], ["resume", true]]) {
+        program.command(name).argument("<id>").description(enabled ? "Enable a cron job" : "Disable a cron job").option("--json", "Print JSON").action((id, options) => {
+            const store = createDefaultPiboCronStore({ path: program.opts().store });
+            const job = store.updateJob(id, { enabled });
+            if (!job)
+                throw new Error("Cron job not found");
+            if (options.json)
+                printJson(job);
+            else
+                console.log(`${job.id}\t${job.enabled ? "enabled" : "disabled"}\t${job.state.nextRunAt ?? "-"}`);
+            store.close();
+        });
+    }
+    program.command("remove").argument("<id>").description("Delete a cron job").option("--json", "Print JSON").action((id, options) => {
+        const store = createDefaultPiboCronStore({ path: program.opts().store });
+        const removed = store.removeJob(id);
+        if (options.json)
+            printJson({ removed });
+        else
+            console.log(removed ? "removed" : "not found");
+        store.close();
+    });
+    program.command("runs").description("List cron runs").option("--job <id>", "Filter by job").option("--json", "Print JSON").action((options) => {
+        const store = createDefaultPiboCronStore({ path: program.opts().store });
+        const runs = store.listRuns({ jobId: options.job });
+        if (options.json)
+            printJson(runs);
+        else
+            for (const run of runs)
+                console.log(`${run.id}\t${run.status}\t${run.createdAt}\t${run.piboSessionId ?? "-"}`);
+        store.close();
+    });
+    await program.parseAsync(argv);
+}

package/dist/cron/plugin.js

@@ -0,0 +1,11 @@
+import { definePiboPlugin } from "../plugins/registry.js";
+import { createPiboCronChannel } from "./channel.js";
+export function createPiboCronPlugin(options = {}) {
+    return definePiboPlugin({
+        id: "pibo.cron",
+        name: "Pibo Cron",
+        register(api) {
+            api.registerChannel(createPiboCronChannel(options));
+        },
+    });
+}

package/dist/cron/schedule.js

@@ -0,0 +1,214 @@
+const MINUTE_MS = 60_000;
+const HOUR_MS = 60 * MINUTE_MS;
+const DAY_MS = 24 * HOUR_MS;
+export function validateSchedule(schedule) {
+    switch (schedule.kind) {
+        case "at": {
+            const date = new Date(schedule.at);
+            if (Number.isNaN(date.getTime()))
+                throw new Error("schedule.at must be a valid date");
+            return;
+        }
+        case "every":
+            if (!Number.isFinite(schedule.everyMs) || schedule.everyMs < MINUTE_MS)
+                throw new Error("schedule.everyMs must be at least one minute");
+            if (schedule.anchorMs !== undefined && !Number.isFinite(schedule.anchorMs))
+                throw new Error("schedule.anchorMs must be finite");
+            return;
+        case "cron":
+            parseCron(schedule.expr);
+            if (schedule.tz)
+                validateTimeZone(schedule.tz);
+            return;
+    }
+}
+export function computeNextRunAt(schedule, now = new Date()) {
+    validateSchedule(schedule);
+    switch (schedule.kind) {
+        case "at": {
+            const at = new Date(schedule.at);
+            return at.getTime() > now.getTime() ? at : undefined;
+        }
+        case "every": {
+            const anchor = schedule.anchorMs ?? 0;
+            const elapsed = now.getTime() - anchor;
+            const steps = Math.floor(elapsed / schedule.everyMs) + 1;
+            return new Date(anchor + Math.max(1, steps) * schedule.everyMs);
+        }
+        case "cron":
+            return computeNextCronRunAt(schedule.expr, now, schedule.tz);
+    }
+}
+export function parseFriendlySchedule(input, now = new Date()) {
+    switch (input.kind) {
+        case "in": {
+            const everyMs = parseDurationMs(input.value);
+            const unit = uiUnit(everyMs);
+            const schedule = { kind: "at", at: new Date(now.getTime() + everyMs).toISOString() };
+            return { schedule, scheduleUi: { preset: "in", amount: amountForUnit(everyMs, unit), unit } };
+        }
+        case "at":
+            return { schedule: { kind: "at", at: new Date(input.value).toISOString() }, scheduleUi: { preset: "at", localDateTime: input.value, tz: input.tz } };
+        case "every": {
+            const everyMs = parseDurationMs(input.value);
+            const unit = uiUnit(everyMs);
+            return { schedule: { kind: "every", everyMs, anchorMs: now.getTime() }, scheduleUi: { preset: "every", amount: amountForUnit(everyMs, unit), unit } };
+        }
+        case "daily": {
+            const { hour, minute } = parseTime(input.time);
+            return { schedule: { kind: "cron", expr: `${minute} ${hour} * * *`, tz: input.tz }, scheduleUi: { preset: "daily", time: input.time, tz: input.tz } };
+        }
+        case "weekly": {
+            const { hour, minute } = parseTime(input.time);
+            const weekdays = Array.isArray(input.weekdays) ? input.weekdays : parseWeekdays(input.weekdays);
+            return { schedule: { kind: "cron", expr: `${minute} ${hour} * * ${weekdays.join(",")}`, tz: input.tz }, scheduleUi: { preset: "weekly", weekdays, time: input.time, tz: input.tz } };
+        }
+        case "monthly": {
+            const { hour, minute } = parseTime(input.time);
+            if (!Number.isInteger(input.dayOfMonth) || input.dayOfMonth < 1 || input.dayOfMonth > 31)
+                throw new Error("monthly day must be between 1 and 31");
+            return { schedule: { kind: "cron", expr: `${minute} ${hour} ${input.dayOfMonth} * *`, tz: input.tz }, scheduleUi: { preset: "monthly", dayOfMonth: input.dayOfMonth, time: input.time, tz: input.tz } };
+        }
+        case "cron":
+            return { schedule: { kind: "cron", expr: input.expr, tz: input.tz }, scheduleUi: { preset: "advanced", expr: input.expr, tz: input.tz } };
+    }
+}
+export function formatSchedule(schedule, scheduleUi) {
+    if (scheduleUi) {
+        switch (scheduleUi.preset) {
+            case "in": return `in ${scheduleUi.amount} ${scheduleUi.unit}`;
+            case "at": return `at ${scheduleUi.localDateTime}`;
+            case "every": return `every ${scheduleUi.amount} ${scheduleUi.unit}`;
+            case "daily": return `daily at ${scheduleUi.time}`;
+            case "weekly": return `weekly ${scheduleUi.weekdays.join(",")} at ${scheduleUi.time}`;
+            case "monthly": return `monthly on day ${scheduleUi.dayOfMonth} at ${scheduleUi.time}`;
+            case "advanced": return `cron ${scheduleUi.expr}`;
+        }
+    }
+    if (schedule.kind === "at")
+        return `at ${schedule.at}`;
+    if (schedule.kind === "every")
+        return `every ${formatDuration(schedule.everyMs)}`;
+    return `cron ${schedule.expr}${schedule.tz ? ` (${schedule.tz})` : ""}`;
+}
+export function parseDurationMs(value) {
+    const match = value.trim().match(/^(\d+(?:\.\d+)?)\s*(m|min|minute|minutes|h|hr|hour|hours|d|day|days)$/i);
+    if (!match)
+        throw new Error("Duration must look like 20m, 2h, or 1d");
+    const amount = Number(match[1]);
+    const unit = match[2].toLowerCase();
+    const ms = unit.startsWith("m") ? amount * MINUTE_MS : unit.startsWith("h") ? amount * HOUR_MS : amount * DAY_MS;
+    if (!Number.isFinite(ms) || ms < MINUTE_MS)
+        throw new Error("Duration must be at least one minute");
+    return Math.round(ms);
+}
+function formatDuration(ms) {
+    if (ms % DAY_MS === 0)
+        return `${ms / DAY_MS}d`;
+    if (ms % HOUR_MS === 0)
+        return `${ms / HOUR_MS}h`;
+    return `${Math.round(ms / MINUTE_MS)}m`;
+}
+function uiUnit(ms) {
+    if (ms % DAY_MS === 0)
+        return "days";
+    if (ms % HOUR_MS === 0)
+        return "hours";
+    return "minutes";
+}
+function amountForUnit(ms, unit) {
+    return unit === "days" ? ms / DAY_MS : unit === "hours" ? ms / HOUR_MS : ms / MINUTE_MS;
+}
+function parseTime(value) {
+    const match = value.trim().match(/^(\d{1,2}):(\d{2})$/);
+    if (!match)
+        throw new Error("Time must use HH:MM");
+    const hour = Number(match[1]);
+    const minute = Number(match[2]);
+    if (hour < 0 || hour > 23 || minute < 0 || minute > 59)
+        throw new Error("Time is out of range");
+    return { hour, minute };
+}
+function parseWeekdays(value) {
+    const names = new Map([["sun", 0], ["mon", 1], ["tue", 2], ["wed", 3], ["thu", 4], ["fri", 5], ["sat", 6]]);
+    const days = value.split(",").map((part) => {
+        const text = part.trim().toLowerCase();
+        const numeric = Number(text);
+        const day = Number.isInteger(numeric) ? numeric : names.get(text.slice(0, 3));
+        if (day === undefined || day < 0 || day > 6)
+            throw new Error(`Invalid weekday: ${part}`);
+        return day;
+    });
+    if (days.length === 0)
+        throw new Error("At least one weekday is required");
+    return [...new Set(days)].sort();
+}
+function parseCron(expr) {
+    const fields = expr.trim().split(/\s+/);
+    if (fields.length !== 5)
+        throw new Error("Cron expression must have 5 fields: minute hour day month weekday");
+    return {
+        minutes: parseCronField(fields[0], 0, 59, "minute"),
+        hours: parseCronField(fields[1], 0, 23, "hour"),
+        days: parseCronField(fields[2], 1, 31, "day"),
+        months: parseCronField(fields[3], 1, 12, "month"),
+        weekdays: parseCronField(fields[4], 0, 7, "weekday", (value) => value === 7 ? 0 : value),
+    };
+}
+function parseCronField(field, min, max, label, mapValue = (value) => value) {
+    const values = new Set();
+    for (const part of field.split(",")) {
+        const [rangePart, stepPart] = part.split("/");
+        const step = stepPart === undefined ? 1 : Number(stepPart);
+        if (!Number.isInteger(step) || step < 1)
+            throw new Error(`Invalid ${label} step`);
+        let start;
+        let end;
+        if (rangePart === "*") {
+            start = min;
+            end = max;
+        }
+        else if (rangePart.includes("-")) {
+            const [left, right] = rangePart.split("-").map(Number);
+            start = left;
+            end = right;
+        }
+        else {
+            start = Number(rangePart);
+            end = start;
+        }
+        if (!Number.isInteger(start) || !Number.isInteger(end) || start < min || end > max || start > end)
+            throw new Error(`Invalid ${label} field`);
+        for (let value = start; value <= end; value += step)
+            values.add(mapValue(value));
+    }
+    return values;
+}
+function computeNextCronRunAt(expr, now, tz) {
+    const spec = parseCron(expr);
+    const start = new Date(Math.floor(now.getTime() / MINUTE_MS) * MINUTE_MS + MINUTE_MS);
+    const max = start.getTime() + 5 * 366 * DAY_MS;
+    for (let time = start.getTime(); time <= max; time += MINUTE_MS) {
+        const date = new Date(time);
+        const parts = cronDateParts(date, tz);
+        if (spec.minutes.has(parts.minute) && spec.hours.has(parts.hour) && spec.days.has(parts.day) && spec.months.has(parts.month) && spec.weekdays.has(parts.weekday))
+            return date;
+    }
+    return undefined;
+}
+function cronDateParts(date, tz) {
+    if (!tz)
+        return { minute: date.getMinutes(), hour: date.getHours(), day: date.getDate(), month: date.getMonth() + 1, weekday: date.getDay() };
+    const parts = new Intl.DateTimeFormat("en-US", { timeZone: tz, minute: "numeric", hour: "numeric", day: "numeric", month: "numeric", weekday: "short", hour12: false }).formatToParts(date);
+    const get = (type) => Number(parts.find((part) => part.type === type)?.value);
+    const weekdays = new Map([["Sun", 0], ["Mon", 1], ["Tue", 2], ["Wed", 3], ["Thu", 4], ["Fri", 5], ["Sat", 6]]);
+    return { minute: get("minute"), hour: get("hour") % 24, day: get("day"), month: get("month"), weekday: weekdays.get(parts.find((part) => part.type === "weekday")?.value ?? "") ?? 0 };
+}
+function validateTimeZone(tz) {
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: tz }).format(new Date());
+    }
+    catch {
+        throw new Error(`Invalid timezone: ${tz}`);
+    }
+}

package/dist/cron/service.js

@@ -0,0 +1,177 @@
+import { randomUUID } from "node:crypto";
+import { getDefaultPiboWorkspace } from "../core/workspace.js";
+import { PiboDataStore } from "../data/pibo-store.js";
+import { ChatRoomService } from "../apps/chat/data/room-service.js";
+import { isPiboRoomArchived } from "../apps/chat/types/rooms.js";
+import { formatSchedule } from "./schedule.js";
+import { createDefaultPiboCronStore } from "./store.js";
+const CHAT_WEB_CHANNEL = "pibo.chat-web";
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function buildCronPrompt(job) {
+    return [
+        "You are running a scheduled Pibo job.",
+        `Job: ${job.name}`,
+        `Schedule: ${formatSchedule(job.schedule, job.scheduleUi)}`,
+        `Target: ${job.target.kind}`,
+        "",
+        "Complete the scheduled task below. Return the result in this session. Do not create another cron job unless the original task explicitly asks for it.",
+        "",
+        "Task:",
+        job.prompt,
+    ].join("\n");
+}
+export class PiboCronService {
+    options;
+    store;
+    dataStore;
+    roomService;
+    intervalMs;
+    maxConcurrentRuns;
+    runTimeoutMs;
+    timer;
+    activeRuns = 0;
+    stopped = true;
+    constructor(options) {
+        this.options = options;
+        this.store = options.store ?? createDefaultPiboCronStore();
+        this.dataStore = new PiboDataStore(options.dataStorePath, { payloadRootDir: options.dataPayloadRootDir });
+        this.roomService = new ChatRoomService(this.dataStore);
+        this.intervalMs = options.intervalMs ?? 60_000;
+        this.maxConcurrentRuns = Math.max(1, options.maxConcurrentRuns ?? 2);
+        this.runTimeoutMs = options.runTimeoutMs ?? 30 * 60_000;
+    }
+    start() {
+        if (!this.stopped)
+            return;
+        this.stopped = false;
+        this.store.recoverInterruptedRuns();
+        this.arm(1000);
+    }
+    stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+        this.dataStore.close();
+        this.store.close();
+    }
+    status() {
+        return { enabled: !this.stopped, ...this.store.status() };
+    }
+    async runJobNow(id) {
+        const reserved = this.store.reserveManualRun(id);
+        if (!reserved)
+            throw new Error("Cron job not found");
+        void this.executeReserved(reserved.job, reserved.run).finally(() => this.armSoon());
+        return reserved.run;
+    }
+    arm(delayMs) {
+        if (this.stopped)
+            return;
+        if (this.timer)
+            clearTimeout(this.timer);
+        const status = this.store.status();
+        const nextDelay = status.nextRunAt ? Math.max(1000, new Date(status.nextRunAt).getTime() - Date.now()) : this.intervalMs;
+        this.timer = setTimeout(() => void this.tick(), Math.min(delayMs ?? nextDelay, this.intervalMs));
+    }
+    armSoon() {
+        this.arm(1000);
+    }
+    async tick() {
+        if (this.stopped)
+            return;
+        try {
+            const capacity = this.maxConcurrentRuns - this.activeRuns;
+            if (capacity > 0) {
+                const due = this.store.reserveDueRuns(capacity);
+                for (const { job, run } of due)
+                    void this.executeReserved(job, run).finally(() => this.armSoon());
+            }
+        }
+        catch (error) {
+            console.error("[cron] scheduler tick failed", error);
+        }
+        finally {
+            this.arm();
+        }
+    }
+    async executeReserved(job, run) {
+        this.activeRuns += 1;
+        try {
+            const piboSessionId = await this.executeJob(job, run);
+            this.store.completeRun({ jobId: job.id, runId: run.id, status: "ok", piboSessionId });
+        }
+        catch (error) {
+            this.store.completeRun({ jobId: job.id, runId: run.id, status: "error", error: errorMessage(error) });
+            console.error(`[cron] job ${job.id} failed`, error);
+        }
+        finally {
+            this.activeRuns -= 1;
+        }
+    }
+    async executeJob(job, run) {
+        const target = this.resolveTarget(job);
+        const session = this.options.context.createSession({
+            channel: CHAT_WEB_CHANNEL,
+            kind: "cron",
+            profile: job.profile,
+            workspace: target.workspace ?? getDefaultPiboWorkspace(),
+            title: job.name,
+            metadata: {
+                ...(target.metadata ?? {}),
+                chatRoomId: target.roomId,
+                cronJobId: job.id,
+                cronRunId: run.id,
+                cronTargetKind: job.target.kind,
+            },
+        });
+        await this.emitMessageAndWait(session.id, buildCronPrompt(job));
+        return session.id;
+    }
+    resolveTarget(job) {
+        if (job.target.kind === "room") {
+            const room = this.roomService.getRoom(job.target.roomId);
+            if (!room)
+                throw new Error("Target room no longer exists");
+            if (isPiboRoomArchived(room))
+                throw new Error("Target room is archived");
+            return { roomId: room.id, workspace: room.workspace ?? getDefaultPiboWorkspace() };
+        }
+        const room = this.roomService.ensureDefaultRoom({ name: "Shared Chat" });
+        return { roomId: room.id, workspace: room.workspace ?? getDefaultPiboWorkspace() };
+    }
+    async emitMessageAndWait(piboSessionId, text) {
+        const eventId = `cron_msg_${randomUUID()}`;
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            let unsubscribe;
+            const timeout = setTimeout(() => {
+                finish(new Error("Cron run timed out"));
+            }, this.runTimeoutMs);
+            const finish = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                unsubscribe?.();
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            };
+            unsubscribe = this.options.context.subscribe((event) => {
+                if (event.piboSessionId !== piboSessionId)
+                    return;
+                if ("eventId" in event && event.eventId !== eventId)
+                    return;
+                if (event.type === "message_finished")
+                    finish();
+                if (event.type === "session_error")
+                    finish(new Error(event.error));
+            });
+            this.options.context.emit({ type: "message", piboSessionId, id: eventId, source: "service", text }).catch((error) => finish(error instanceof Error ? error : new Error(String(error))));
+        });
+    }
+}