@pasko70/pibo 1.9.7 → 1.9.9

package/dist/cron/cli.js

@@ -1,230 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,214 +0,0 @@
-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

@@ -1,177 +0,0 @@
-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))));
-        });
-    }
-}