loopengine 0.1.69 → 0.1.70

package/README.md

@@ -121,6 +121,7 @@ code changes or redeploy needed for most of it:
 | **Tools** | Your hand-written tools, tools from integrations (e.g. [Composio](https://composio.dev)) and subagents, with whether each call runs on its own, asks first, or is denied. Build an HTTP tool or connect an integration without touching a file. |
 | **Skills** | Create, edit, and delete `SKILL.md` files for this agent directly in the browser — write the body, preview the rendered markdown, save. |
 | **Permissions** | Add, edit, and delete permission rules (actauth) — who, tool, decision — and choose what happens when no rule matches. |
+| **Schedules** | Messages the agent receives on a timer — once at a set time, or every N minutes/hours/days. Run now, pause, resume, cancel, see each run's result, and optionally send results through the agent's notifier. |
 | **Environment** | Every setting an installed ability reads, with its project-wide value and this agent's own value side by side, and which one the agent actually uses. A secret is never shown again once set. |
 
 Models and Integrations in the sidebar show which model providers have a
@@ -211,6 +212,30 @@ click, a webhook HMAC signature, a magic-link token) ship under
 live and durable, worked examples, and how resumption actually works
 under the hood.
 
+## Scheduled tasks
+
+The server runs one scheduler (`core/scheduler.ts`) that sends a message
+to an agent later — once (`run_at`) or on an interval (`every: "1h"`) —
+from the console's **Schedules** tab, the `GET/POST
+/agents/<name>/schedules` API, or the agent itself: every agent has
+built-in `system_schedule_task`, `system_list_scheduled_tasks`,
+`system_check_scheduled_task` and `system_cancel_scheduled_task` tools,
+so "remind me tomorrow at 9" just works. An
+agent can only schedule, see or cancel its own tasks, up to 25 active at
+a time (`LOOPENGINE_SCHEDULER_MAX_PER_AGENT`); `selfScheduling: false` in
+its config removes the tools. Tasks left by the old `lp-task-scheduler`
+ability are imported at start. Each run goes through the same
+path as an HTTP call: an approval goes wherever the Permissions tab sends
+it (and resumes the run once decided); with nowhere set, a call that
+needs approval is denied. Intervals keep their original slot (an hourly
+task created at 10:07 stays on :07); a run missed while the server was
+down fires once when it's back. Tasks live in `.scheduler/` (or
+`LOOPENGINE_SCHEDULER_DIR`); the tick is `LOOPENGINE_SCHEDULER_TICK_MS`
+(10 s); `LOOPENGINE_SCHEDULER=off` turns the loop off for this process.
+Behind a hosting platform, `GET /internal/activity` reports `nextWakeAt`
+and `POST /internal/scheduler/tick` fires whatever is due, so a stopped
+server can be woken in time.
+
 ## Ability system
 
 Giving an agent a new capability is usually three separate, hand-authored

package/dist/core/agent-config.d.ts

@@ -399,6 +399,12 @@ export interface AgentConfig {
      * for `cli`/`http_stream`: both always get the library's own live
      * defaults, with nothing to configure. */
     httpNotifier?: HttpNotifierConfig;
+    /** Whether this agent gets the built-in scheduling tools
+     * (system_schedule_task and friends, core/system-tools/schedule.ts),
+     * which let it schedule messages to itself — reminders, recurring
+     * checks — and list or cancel its own scheduled tasks. Default true;
+     * false leaves them out of this agent's tools entirely. */
+    selfScheduling?: boolean;
     /** Fires once, fire-and-forget, at the start of every `runAgent()`/
      * `resumeAgent()` call on the `http` channel (or no channel at all —
      * see below) — the "someone triggered this agent" signal, for

package/dist/core/run-agent.js

@@ -19,7 +19,7 @@ import { recordUsage } from './usage.js';
 import { loadAgentModule } from './discover-agents.js';
 import { agentAsTool } from './agent-as-tool.js';
 import { loadGatewayToolsFromDir } from './gateway-tools.js';
-import { systemTools, createAskUserTool, CliQuestionHandler, isDurableQuestionHandler } from './system-tools/index.js';
+import { systemTools, createAskUserTool, createScheduleTools, CliQuestionHandler, isDurableQuestionHandler } from './system-tools/index.js';
 import { resolveHttpNotifier } from './http-notifier.js';
 import { CRASH_RECOVERY_CONTINUATION } from './session-store.js';
 export { systemTools } from './system-tools/index.js';
@@ -296,9 +296,14 @@ async function buildTurnContext(config, modelCall, options) {
     // (options.onEvent's own fallback) — see RunAgentOptions.onQuestionPending's
     // own doc comment for why those two are deliberately not the same thing.
     const askUserTool = createAskUserTool({ agent: config.name, sessionId: options.sessionId }, options.onQuestionPending);
+    // Bound to this agent: it can schedule, list and cancel only its own
+    // tasks (see core/system-tools/schedule.ts). AgentConfig.selfScheduling
+    // false leaves them out.
+    const scheduleTools = config.selfScheduling === false ? [] : createScheduleTools(config.name);
     const tools = dedupeToolsByName([
         ...systemTools,
         askUserTool,
+        ...scheduleTools,
         ...(config.tools ?? (await loadDefaultTools(config))),
         ...(await loadSubagentAsTools(config)),
         ...(await loadGatewayToolsFromDir(join(process.cwd(), 'agents', config.name))),
@@ -390,7 +395,7 @@ async function buildTurnContext(config, modelCall, options) {
     // ('ask' or 'deny', see loadRules' own doc comment) would otherwise
     // catch it, since neither system tool ever appears in an agent's own
     // actauth.yml.
-    const systemToolInstances = new Set([...systemTools, askUserTool]);
+    const systemToolInstances = new Set([...systemTools, askUserTool, ...scheduleTools]);
     const toolSchemas = tools.map(({ name, description, input_schema }) => ({
         name,
         description,

package/dist/core/scheduler.d.ts

@@ -0,0 +1,143 @@
+export type Schedule = {
+    run_at: string;
+} | {
+    every: string;
+    anchor?: string;
+};
+export type ScheduledTaskStatus = 'scheduled' | 'running' | 'awaiting_approval' | 'paused' | 'done' | 'cancelled';
+export interface ScheduledTaskRun {
+    ran_at: string;
+    status: 'ok' | 'error';
+    result?: string;
+    error?: string;
+    session_id?: string;
+}
+export interface ScheduledTask {
+    task_id: string;
+    task_name?: string;
+    agent: string;
+    message: string;
+    schedule: Schedule;
+    status: ScheduledTaskStatus;
+    created_at: string;
+    next_run_at?: string;
+    run_count: number;
+    last_run_at?: string;
+    last_status?: 'ok' | 'error';
+    last_result?: string;
+    last_error?: string;
+    /** Set while a run is paused on an approval or question. */
+    pending?: {
+        ran_at: string;
+        session_id: string;
+        pending_ids: string[];
+    };
+    /** Send each run's result through the agent's notifier. */
+    notify?: boolean;
+    history: ScheduledTaskRun[];
+    /** Set by "run now" on a paused or finished task, so it goes back to
+     * that status after the extra run. */
+    run_now_from?: 'paused' | 'done';
+    /** Set by cancelling a run that's waiting on an approval: cancelled
+     * once that run finishes. */
+    cancel_after_run?: boolean;
+}
+export declare class ScheduleError extends Error {
+}
+export declare function parseEvery(every: string): number;
+/** Human-readable schedule, for lists and messages. */
+export declare function describeSchedule(schedule: Schedule): string;
+export interface SchedulerStore {
+    list(): Promise<ScheduledTask[]>;
+    get(taskId: string): Promise<ScheduledTask | undefined>;
+    put(task: ScheduledTask): Promise<void>;
+    remove(taskId: string): Promise<void>;
+    /** Runs `fn` with exclusive access to one task (read, change, write). */
+    update(taskId: string, fn: (task: ScheduledTask | undefined) => ScheduledTask | undefined): Promise<ScheduledTask | undefined>;
+}
+/** One JSON file per task under `<dir>/tasks/` — one server process. */
+export declare class FileSchedulerStore implements SchedulerStore {
+    private readonly dir;
+    constructor(dir: string);
+    private file;
+    list(): Promise<ScheduledTask[]>;
+    get(taskId: string): Promise<ScheduledTask | undefined>;
+    put(task: ScheduledTask): Promise<void>;
+    remove(taskId: string): Promise<void>;
+    update(taskId: string, fn: (task: ScheduledTask | undefined) => ScheduledTask | undefined): Promise<ScheduledTask | undefined>;
+}
+/** The process-wide store: `.scheduler/` in the project, or
+ * LOOPENGINE_SCHEDULER_DIR. */
+export declare function getSchedulerStore(): SchedulerStore;
+export declare function setSchedulerStore(next: SchedulerStore): void;
+export interface CreateScheduledTaskInput {
+    agent: string;
+    message: string;
+    schedule: {
+        run_at?: unknown;
+        every?: unknown;
+    };
+    task_name?: string;
+    notify?: boolean;
+}
+export declare function createScheduledTask(input: CreateScheduledTaskInput, nowMs?: number): Promise<ScheduledTask>;
+export declare function listScheduledTasks(filter?: {
+    agent?: string;
+    status?: ScheduledTaskStatus;
+}): Promise<ScheduledTask[]>;
+export declare function getScheduledTask(taskId: string): Promise<ScheduledTask | undefined>;
+/** Stops future runs; history stays. A run already waiting on an
+ * approval isn't retracted. */
+export declare function cancelScheduledTask(taskId: string): Promise<ScheduledTask>;
+export declare function pauseScheduledTask(taskId: string): Promise<ScheduledTask>;
+export declare function resumeScheduledTask(taskId: string, nowMs?: number): Promise<ScheduledTask>;
+/** Fires the task on the next tick, without changing its schedule. A
+ * finished one-off task runs once more. */
+export declare function runScheduledTaskNow(taskId: string, nowMs?: number): Promise<ScheduledTask>;
+export declare function deleteScheduledTask(taskId: string): Promise<void>;
+/** When the next task is due — for a host that stops idle servers and
+ * needs to wake this one in time (GET /internal/activity). */
+export declare function nextScheduledWakeAt(): Promise<string | undefined>;
+/** Moves the old lp-task-scheduler's task files (`<dir>/.tasks/*.json`)
+ * into this store once, renaming each to `.json.migrated`. Returns how
+ * many it imported. */
+export declare function importLegacyScheduledTasks(dir: string): Promise<number>;
+/** How a task fires — supplied by the server. `done`: the agent replied;
+ * `pending`: the run is paused on approvals/questions (see settleFromResume). */
+export type FireTask = (task: ScheduledTask, sessionId: string) => Promise<{
+    kind: 'done';
+    text: string;
+} | {
+    kind: 'pending';
+    pendingIds: string[];
+}>;
+export declare class Scheduler {
+    private readonly fire;
+    private readonly tickMs;
+    private readonly onSettled?;
+    private readonly inFlight;
+    private timer?;
+    constructor(options: {
+        fire: FireTask;
+        tickMs?: number;
+        onSettled?: (task: ScheduledTask, run: ScheduledTaskRun) => void;
+    });
+    /** Imports tasks left by the old lp-task-scheduler ability, recovers
+     * runs a restart cut off, then ticks every `tickMs`. */
+    start(): Promise<void>;
+    stop(): void;
+    /** How many runs are executing right now (for idle-shutdown checks). */
+    get running(): number;
+    /** Fires every task that's due. Safe to call any time (a host's wake-up
+     * request calls it directly). */
+    tick(nowMs?: number): Promise<number>;
+    private run;
+    /** A paused run resumed after a decision (adapters/http.ts calls this
+     * from the resolve path): settle it, or record the next decision it's
+     * now waiting on. */
+    settleFromResume(sessionId: string, outcome: {
+        text: string;
+        pendingIds?: string[];
+    }): Promise<void>;
+    private settle;
+}

package/dist/core/scheduler.js

@@ -0,0 +1,359 @@
+// Scheduled tasks: "send this message to that agent later — once, or
+// every N minutes". One scheduler per server, started at boot by
+// adapters/http.ts, which also supplies how a task actually fires (the
+// same turn path as POST /agents/:name/messages, so approvals, notifiers
+// and decision links behave exactly as they do for any HTTP call).
+//
+// Everything a tool or the console needs — create, list, pause, cancel —
+// works on the store directly (below), so it works whether or not this
+// process is the one running the loop; the loop picks changes up on its
+// next tick.
+//
+// `every` is anchored: an hourly task created at 10:07 keeps firing at
+// :07, however long each run takes. A run missed while the server was
+// down fires once when it's back, then the schedule moves to the next
+// future slot (no burst of catch-up runs).
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { KeyedMutex } from './session-store.js';
+const HISTORY_LIMIT = 20;
+const EVERY_PATTERN = /^(\d+)\s*(s|m|h|d)$/;
+const EVERY_UNIT_MS = { s: 1_000, m: 60_000, h: 3_600_000, d: 86_400_000 };
+/** Shortest allowed interval, so a typo can't hammer the model. */
+const MIN_EVERY_MS = 30_000;
+export class ScheduleError extends Error {
+}
+export function parseEvery(every) {
+    const match = EVERY_PATTERN.exec(every.trim());
+    if (!match)
+        throw new ScheduleError(`"${every}" is not a valid interval — use a number followed by s/m/h/d, e.g. "30m", "1h", "1d"`);
+    const ms = Number(match[1]) * EVERY_UNIT_MS[match[2]];
+    if (ms < MIN_EVERY_MS)
+        throw new ScheduleError(`"${every}" is too short — the shortest interval is 30s`);
+    return ms;
+}
+/** The first anchored slot strictly after `nowMs`. */
+function nextAnchoredSlot(anchorMs, intervalMs, nowMs) {
+    if (nowMs < anchorMs)
+        return anchorMs;
+    return anchorMs + (Math.floor((nowMs - anchorMs) / intervalMs) + 1) * intervalMs;
+}
+/** Human-readable schedule, for lists and messages. */
+export function describeSchedule(schedule) {
+    return 'run_at' in schedule ? `once at ${schedule.run_at}` : `every ${schedule.every}`;
+}
+const fileMutex = new KeyedMutex();
+/** One JSON file per task under `<dir>/tasks/` — one server process. */
+export class FileSchedulerStore {
+    dir;
+    constructor(dir) {
+        this.dir = path.join(dir, 'tasks');
+    }
+    file(taskId) {
+        if (!/^[A-Za-z0-9_-]+$/.test(taskId))
+            throw new ScheduleError(`invalid task id "${taskId}"`);
+        return path.join(this.dir, `${taskId}.json`);
+    }
+    async list() {
+        if (!existsSync(this.dir))
+            return [];
+        const tasks = [];
+        for (const name of readdirSync(this.dir)) {
+            if (!name.endsWith('.json'))
+                continue;
+            try {
+                tasks.push(JSON.parse(readFileSync(path.join(this.dir, name), 'utf8')));
+            }
+            catch {
+                // mid-write or removed between readdir and read
+            }
+        }
+        return tasks.sort((a, b) => a.created_at.localeCompare(b.created_at));
+    }
+    async get(taskId) {
+        const file = this.file(taskId);
+        return existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : undefined;
+    }
+    async put(task) {
+        mkdirSync(this.dir, { recursive: true });
+        const file = this.file(task.task_id);
+        writeFileSync(file + '.tmp', JSON.stringify(task, null, 2));
+        renameSync(file + '.tmp', file);
+    }
+    async remove(taskId) {
+        rmSync(this.file(taskId), { force: true });
+    }
+    async update(taskId, fn) {
+        return fileMutex.run(taskId, async () => {
+            const next = fn(await this.get(taskId));
+            if (next)
+                await this.put(next);
+            return next;
+        });
+    }
+}
+let store;
+/** The process-wide store: `.scheduler/` in the project, or
+ * LOOPENGINE_SCHEDULER_DIR. */
+export function getSchedulerStore() {
+    store ??= new FileSchedulerStore(process.env.LOOPENGINE_SCHEDULER_DIR || path.join(process.cwd(), '.scheduler'));
+    return store;
+}
+export function setSchedulerStore(next) {
+    store = next;
+}
+export async function createScheduledTask(input, nowMs = Date.now()) {
+    if (!input.agent)
+        throw new ScheduleError('agent is required');
+    if (!input.message?.trim())
+        throw new ScheduleError('message is required');
+    let schedule;
+    let nextRunMs;
+    if (typeof input.schedule?.run_at === 'string' && input.schedule.run_at) {
+        const runAtMs = Date.parse(input.schedule.run_at);
+        if (Number.isNaN(runAtMs))
+            throw new ScheduleError(`"${input.schedule.run_at}" is not a valid ISO 8601 timestamp`);
+        schedule = { run_at: new Date(runAtMs).toISOString() };
+        nextRunMs = runAtMs;
+    }
+    else if (typeof input.schedule?.every === 'string' && input.schedule.every) {
+        const intervalMs = parseEvery(input.schedule.every);
+        nextRunMs = nowMs + intervalMs;
+        schedule = { every: input.schedule.every.trim(), anchor: new Date(nextRunMs).toISOString() };
+    }
+    else {
+        throw new ScheduleError('schedule must be { "run_at": "<ISO timestamp>" } or { "every": "<interval, e.g. 1h>" }');
+    }
+    const task = {
+        task_id: randomUUID(),
+        task_name: input.task_name?.trim() || undefined,
+        agent: input.agent,
+        message: input.message,
+        schedule,
+        status: 'scheduled',
+        created_at: new Date(nowMs).toISOString(),
+        next_run_at: new Date(nextRunMs).toISOString(),
+        run_count: 0,
+        notify: input.notify || undefined,
+        history: [],
+    };
+    await getSchedulerStore().put(task);
+    return task;
+}
+export async function listScheduledTasks(filter = {}) {
+    return (await getSchedulerStore().list()).filter((t) => (!filter.agent || t.agent === filter.agent) && (!filter.status || t.status === filter.status));
+}
+export async function getScheduledTask(taskId) {
+    return getSchedulerStore().get(taskId);
+}
+function mustExist(task, taskId) {
+    if (!task)
+        throw new ScheduleError(`no scheduled task "${taskId}"`);
+    return task;
+}
+/** Stops future runs; history stays. A run already waiting on an
+ * approval isn't retracted. */
+export async function cancelScheduledTask(taskId) {
+    return mustExist(await getSchedulerStore().update(taskId, (t) => !t ? t : t.status === 'awaiting_approval' ? { ...t, cancel_after_run: true } : { ...t, status: 'cancelled', next_run_at: undefined }), taskId);
+}
+export async function pauseScheduledTask(taskId) {
+    return mustExist(await getSchedulerStore().update(taskId, (t) => (t && t.status === 'scheduled' ? { ...t, status: 'paused', next_run_at: undefined } : t)), taskId);
+}
+export async function resumeScheduledTask(taskId, nowMs = Date.now()) {
+    return mustExist(await getSchedulerStore().update(taskId, (t) => {
+        if (!t || t.status !== 'paused')
+            return t;
+        return { ...t, status: 'scheduled', next_run_at: new Date(nextRunAfter(t, nowMs) ?? nowMs).toISOString() };
+    }), taskId);
+}
+/** Fires the task on the next tick, without changing its schedule. A
+ * finished one-off task runs once more. */
+export async function runScheduledTaskNow(taskId, nowMs = Date.now()) {
+    return mustExist(await getSchedulerStore().update(taskId, (t) => {
+        if (!t || t.status === 'running' || t.status === 'awaiting_approval' || t.status === 'cancelled')
+            return t;
+        return { ...t, status: 'scheduled', next_run_at: new Date(nowMs).toISOString(), run_now_from: t.status === 'paused' || t.status === 'done' ? t.status : undefined };
+    }), taskId);
+}
+export async function deleteScheduledTask(taskId) {
+    await getSchedulerStore().remove(taskId);
+}
+/** When the next task is due — for a host that stops idle servers and
+ * needs to wake this one in time (GET /internal/activity). */
+export async function nextScheduledWakeAt() {
+    const due = (await getSchedulerStore().list()).filter((t) => t.status === 'scheduled' && t.next_run_at).map((t) => t.next_run_at);
+    return due.sort()[0];
+}
+function nextRunAfter(task, nowMs) {
+    if ('run_at' in task.schedule)
+        return undefined;
+    const intervalMs = parseEvery(task.schedule.every);
+    const anchorMs = task.schedule.anchor ? Date.parse(task.schedule.anchor) : Date.parse(task.created_at) + intervalMs;
+    return nextAnchoredSlot(anchorMs, intervalMs, nowMs);
+}
+/** Moves the old lp-task-scheduler's task files (`<dir>/.tasks/*.json`)
+ * into this store once, renaming each to `.json.migrated`. Returns how
+ * many it imported. */
+export async function importLegacyScheduledTasks(dir) {
+    const legacyDir = path.join(dir, '.tasks');
+    if (!existsSync(legacyDir))
+        return 0;
+    let imported = 0;
+    for (const name of readdirSync(legacyDir)) {
+        if (!name.endsWith('.json'))
+            continue;
+        const file = path.join(legacyDir, name);
+        try {
+            const old = JSON.parse(readFileSync(file, 'utf8'));
+            if (!(await getSchedulerStore().get(old.task_id))) {
+                const task = { ...old, history: old.history ?? [], run_count: old.run_count ?? 0 };
+                if ('every' in task.schedule && !task.schedule.anchor && task.next_run_at)
+                    task.schedule = { ...task.schedule, anchor: task.next_run_at };
+                await getSchedulerStore().put(task);
+                imported++;
+            }
+            renameSync(file, file + '.migrated');
+        }
+        catch (err) {
+            console.error(`[loopengine] could not import legacy scheduled task ${file}:`, err);
+        }
+    }
+    return imported;
+}
+/** lp-task-scheduler 1.x kept tasks under
+ * generated/scheduled-tasks/<agent>/.tasks/ (or SCHEDULER_STORE_DIR) and
+ * ran its own timer; scheduling is built in now, so the server imports
+ * those once at start. */
+async function importLegacyAbilityTasks() {
+    const dirs = new Set();
+    const root = path.join(process.cwd(), 'generated', 'scheduled-tasks');
+    if (existsSync(root)) {
+        dirs.add(root);
+        for (const name of readdirSync(root))
+            if (name !== '.tasks')
+                dirs.add(path.join(root, name));
+    }
+    if (process.env.SCHEDULER_STORE_DIR)
+        dirs.add(path.resolve(process.env.SCHEDULER_STORE_DIR));
+    for (const dir of dirs) {
+        const n = await importLegacyScheduledTasks(dir);
+        if (n)
+            console.log(`[loopengine] imported ${n} scheduled task(s) from ${dir}`);
+    }
+}
+export class Scheduler {
+    fire;
+    tickMs;
+    onSettled;
+    inFlight = new Set();
+    timer;
+    constructor(options) {
+        this.fire = options.fire;
+        this.tickMs = options.tickMs ?? (Number(process.env.LOOPENGINE_SCHEDULER_TICK_MS) || 10_000);
+        this.onSettled = options.onSettled;
+    }
+    /** Imports tasks left by the old lp-task-scheduler ability, recovers
+     * runs a restart cut off, then ticks every `tickMs`. */
+    async start() {
+        await importLegacyAbilityTasks();
+        for (const task of await getSchedulerStore().list()) {
+            if (task.status === 'running')
+                await this.settle(task.task_id, new Date().toISOString(), { status: 'error', error: 'The server restarted while this run was in progress.' });
+        }
+        await this.tick();
+        this.timer = setInterval(() => void this.tick().catch((err) => console.error('[loopengine] scheduler tick failed:', err)), this.tickMs);
+        this.timer.unref?.();
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+    }
+    /** How many runs are executing right now (for idle-shutdown checks). */
+    get running() {
+        return this.inFlight.size;
+    }
+    /** Fires every task that's due. Safe to call any time (a host's wake-up
+     * request calls it directly). */
+    async tick(nowMs = Date.now()) {
+        let fired = 0;
+        for (const task of await getSchedulerStore().list()) {
+            if (task.status !== 'scheduled' || !task.next_run_at || Date.parse(task.next_run_at) > nowMs || this.inFlight.has(task.task_id))
+                continue;
+            fired++;
+            this.inFlight.add(task.task_id);
+            void this.run(task.task_id).finally(() => this.inFlight.delete(task.task_id));
+        }
+        return fired;
+    }
+    async run(taskId) {
+        const ranAt = new Date().toISOString();
+        const claimed = await getSchedulerStore().update(taskId, (t) => (t && t.status === 'scheduled' ? { ...t, status: 'running' } : t));
+        if (!claimed || claimed.status !== 'running')
+            return;
+        const sessionId = `sched-${taskId.slice(0, 8)}-${claimed.run_count + 1}-${Date.now().toString(36)}`;
+        try {
+            const outcome = await this.fire(claimed, sessionId);
+            if (outcome.kind === 'pending') {
+                await getSchedulerStore().update(taskId, (t) => t && {
+                    ...t,
+                    status: 'awaiting_approval',
+                    next_run_at: undefined,
+                    pending: { ran_at: ranAt, session_id: sessionId, pending_ids: outcome.pendingIds },
+                    // Cancelled while this run was starting: finish this run, then stop.
+                    cancel_after_run: t.cancel_after_run || t.status === 'cancelled' || undefined,
+                });
+                return;
+            }
+            await this.settle(taskId, ranAt, { status: 'ok', result: outcome.text, session_id: sessionId });
+        }
+        catch (err) {
+            await this.settle(taskId, ranAt, { status: 'error', error: err instanceof Error ? err.message : String(err), session_id: sessionId });
+        }
+    }
+    /** A paused run resumed after a decision (adapters/http.ts calls this
+     * from the resolve path): settle it, or record the next decision it's
+     * now waiting on. */
+    async settleFromResume(sessionId, outcome) {
+        if (!sessionId.startsWith('sched-'))
+            return;
+        const task = (await getSchedulerStore().list()).find((t) => t.pending?.session_id === sessionId);
+        if (!task)
+            return;
+        if (outcome.pendingIds?.length) {
+            await getSchedulerStore().update(task.task_id, (t) => t && t.pending && { ...t, pending: { ...t.pending, pending_ids: outcome.pendingIds } });
+            return;
+        }
+        await this.settle(task.task_id, task.pending.ran_at, { status: 'ok', result: outcome.text, session_id: sessionId });
+    }
+    async settle(taskId, ranAt, run) {
+        const nowMs = Date.now();
+        const entry = { ran_at: ranAt, ...run };
+        const settled = await getSchedulerStore().update(taskId, (t) => {
+            if (!t)
+                return t;
+            const history = [...t.history, entry].slice(-HISTORY_LIMIT);
+            const base = {
+                ...t,
+                run_count: t.run_count + 1,
+                last_run_at: ranAt,
+                last_status: run.status,
+                last_result: run.result,
+                last_error: run.error,
+                pending: undefined,
+                history,
+                run_now_from: undefined,
+                cancel_after_run: undefined,
+            };
+            if (t.cancel_after_run || t.status === 'cancelled')
+                return { ...base, status: 'cancelled', next_run_at: undefined };
+            // A "run now" of a paused or finished task goes back to how it was.
+            if (t.run_now_from)
+                return { ...base, status: t.run_now_from, next_run_at: undefined };
+            const next = nextRunAfter(t, nowMs);
+            return next === undefined ? { ...base, status: 'done', next_run_at: undefined } : { ...base, status: 'scheduled', next_run_at: new Date(next).toISOString() };
+        });
+        if (settled)
+            this.onSettled?.(settled, entry);
+    }
+}

package/dist/core/system-tools/index.d.ts

@@ -1,3 +1,4 @@
 import type { ToolDefinition } from '../agent-config.js';
 export declare const systemTools: ToolDefinition[];
+export { createScheduleTools } from './schedule.js';
 export { createAskUserTool, listQuestions, answerQuestion, findQuestion, CliQuestionHandler, WebchatQuestionHandler, isDurableQuestionHandler, type PendingQuestion, } from './ask_user.js';

package/dist/core/system-tools/index.js

@@ -9,4 +9,5 @@
 // re-exported here instead of an instance.
 import { readFile } from './read_file.js';
 export const systemTools = [readFile];
+export { createScheduleTools } from './schedule.js';
 export { createAskUserTool, listQuestions, answerQuestion, findQuestion, CliQuestionHandler, WebchatQuestionHandler, isDurableQuestionHandler, } from './ask_user.js';

package/dist/core/system-tools/schedule.d.ts

@@ -0,0 +1,2 @@
+import type { ToolDefinition } from '../agent-config.js';
+export declare function createScheduleTools(agentName: string): ToolDefinition[];

package/dist/core/system-tools/schedule.js

@@ -0,0 +1,111 @@
+import { cancelScheduledTask, createScheduledTask, getScheduledTask, listScheduledTasks, } from '../scheduler.js';
+/** How many active (not done or cancelled) tasks one agent may create
+ * through these tools — each run is a model call, so a runaway loop of
+ * "schedule another one" stops here. The console and API aren't capped. */
+function maxActivePerAgent() {
+    const n = Number(process.env.LOOPENGINE_SCHEDULER_MAX_PER_AGENT);
+    return Number.isInteger(n) && n > 0 ? n : 25;
+}
+function summary(t) {
+    return {
+        task_id: t.task_id,
+        task_name: t.task_name,
+        message: t.message,
+        schedule: t.schedule,
+        status: t.status,
+        next_run_at: t.next_run_at,
+        run_count: t.run_count,
+        last_status: t.last_status,
+    };
+}
+export function createScheduleTools(agentName) {
+    async function ownTask(taskId, tool) {
+        const task = await getScheduledTask(taskId);
+        // Another agent's task reads exactly like a missing one.
+        if (!task || task.agent !== agentName)
+            throw new Error(`${tool}: no scheduled task "${taskId}" for this agent`);
+        return task;
+    }
+    const scheduleTask = {
+        name: 'system_schedule_task',
+        description: 'Schedule a message to yourself for later — once at a set time, or repeatedly on an interval — like setting a reminder or a cron job. When it fires you receive the message as a new conversation (none of the current one carries over, so make the message self-contained) and handle it with your tools as usual, with no person live. A tool call that needs approval goes wherever your approval requests are sent and waits; if nowhere is set, it is denied. Use only when the user asks for something to happen later or regularly, never on your own initiative. Use the user\'s time zone (ask if unclear), prefer the longest interval that serves them since each run is a model call, and confirm the schedule back in plain words. Returns task_id and next_run_at.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                message: {
+                    type: 'string',
+                    description: 'What you will receive when the task fires, written as an instruction to your future self with every detail it needs, e.g. "Check whether order 4417 has shipped and email the customer at a@example.com if it has."',
+                },
+                schedule: {
+                    type: 'object',
+                    description: 'Either { "run_at": "<ISO 8601 timestamp with time zone>" } for once, or { "every": "<interval>" } to repeat until cancelled — a number plus s/m/h/d, e.g. "30m", "1h", "1d"; 30s at the shortest. A repeating task keeps its first slot: started at 10:07 with "1h", it fires at 11:07, 12:07, ...',
+                    properties: { run_at: { type: 'string' }, every: { type: 'string' } },
+                },
+                task_name: { type: 'string', description: 'Optional short label, shown when listing tasks and in the console.' },
+                notify: { type: 'boolean', description: 'Optional — also send each run\'s result through your notifier (where your approval requests go), so a person sees it.' },
+            },
+            required: ['message', 'schedule'],
+        },
+        execute: async (input) => {
+            const active = (await listScheduledTasks({ agent: agentName })).filter((t) => t.status !== 'done' && t.status !== 'cancelled');
+            if (active.length >= maxActivePerAgent()) {
+                throw new Error(`system_schedule_task: you already have ${active.length} active scheduled tasks (the limit is ${maxActivePerAgent()}); cancel one you no longer need first`);
+            }
+            const task = await createScheduledTask({
+                agent: agentName,
+                message: String(input.message ?? ''),
+                schedule: (input.schedule ?? {}),
+                task_name: typeof input.task_name === 'string' ? input.task_name : undefined,
+                notify: input.notify === true,
+            });
+            return JSON.stringify({ task_id: task.task_id, next_run_at: task.next_run_at, schedule: task.schedule });
+        },
+    };
+    const listTasks = {
+        name: 'system_list_scheduled_tasks',
+        description: 'List your own scheduled tasks (task_id, name, message, schedule, status, next_run_at, run_count, last_status). Check this before scheduling something recurring, so you don\'t create a duplicate. status "awaiting_approval" means a run is waiting on someone to approve or answer.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                status: {
+                    type: 'string',
+                    enum: ['scheduled', 'running', 'awaiting_approval', 'paused', 'done', 'cancelled'],
+                    description: 'Optional — only tasks with this status.',
+                },
+            },
+        },
+        execute: async (input) => {
+            const status = typeof input.status === 'string' ? input.status : undefined;
+            return JSON.stringify((await listScheduledTasks({ agent: agentName, status })).map(summary));
+        },
+        safe: true,
+    };
+    const checkTask = {
+        name: 'system_check_scheduled_task',
+        description: 'Get one of your scheduled tasks in full — schedule, status, next_run_at, and recent runs, each "ok" with your reply from that run or "error" with what went wrong (for example, a call that needed approval was denied because nowhere is set to send approval requests).',
+        input_schema: {
+            type: 'object',
+            properties: { task_id: { type: 'string', description: 'The task_id from system_schedule_task or system_list_scheduled_tasks.' } },
+            required: ['task_id'],
+        },
+        execute: async (input) => JSON.stringify(await ownTask(String(input.task_id ?? ''), 'system_check_scheduled_task')),
+        safe: true,
+    };
+    const cancelTask = {
+        name: 'system_cancel_scheduled_task',
+        description: 'Cancel one of your scheduled tasks so it doesn\'t fire again. A run already waiting on an approval finishes first. Its history stays (status "cancelled").',
+        input_schema: {
+            type: 'object',
+            properties: { task_id: { type: 'string', description: 'The task_id from system_schedule_task or system_list_scheduled_tasks.' } },
+            required: ['task_id'],
+        },
+        execute: async (input) => {
+            const task = await ownTask(String(input.task_id ?? ''), 'system_cancel_scheduled_task');
+            if (task.status === 'cancelled')
+                return JSON.stringify({ task_id: task.task_id, status: 'cancelled', already: true });
+            const after = await cancelScheduledTask(task.task_id);
+            return JSON.stringify({ task_id: task.task_id, status: after.status, ...(after.cancel_after_run ? { note: 'cancels once the run waiting on an approval finishes' } : {}) });
+        },
+    };
+    return [scheduleTask, listTasks, checkTask, cancelTask];
+}

package/dist/index.d.ts

@@ -10,12 +10,13 @@ export { setUsageSink, recordUsage, type UsageEvent, type UsageSink } from '#cor
 export { readNotifierFile, writeNotifierFile, removeNotifierFile, validateNotifierFile, notifierConfigFromFile, NotifierFileError, NOTIFIER_SECRET_VARS, type NotifierFile } from '#core/notifier-file.js';
 export { listDeliveries, recordDelivery, type NotifierDelivery } from '#core/notifier-deliveries.js';
 export { describeNotifier } from '#core/http-notifier.js';
+export { Scheduler, ScheduleError, FileSchedulerStore, getSchedulerStore, setSchedulerStore, createScheduledTask, listScheduledTasks, getScheduledTask, cancelScheduledTask, pauseScheduledTask, resumeScheduledTask, runScheduledTaskNow, deleteScheduledTask, nextScheduledWakeAt, importLegacyScheduledTasks, parseEvery, describeSchedule, type ScheduledTask, type ScheduledTaskRun, type ScheduledTaskStatus, type Schedule, type SchedulerStore, type FireTask, type CreateScheduledTaskInput } from '#core/scheduler.js';
 export { verifySlackRequest, parseSlackInteraction, openSlackAnswerModal, replyInSlack, slackOutcomeText, listSlackChannels, slackAppManifest, type SlackInteraction, type SlackChannel } from '#core/slack-interactions.js';
 export { NOTIFIER_SLACK_SIGNING_SECRET_VAR } from '#core/notifier-file.js';
 export { createDecisionToken, verifyDecisionToken, decidePath, decideLinkMaker, decisionLinkTtlMs, type DecisionKind } from '#core/approval-links.js';
 export { renderDecidePage, renderDecideGonePage, renderDecideInvalidPage, type DecidePageItem } from './web/decide-page.js';
 export { sendTestWebhook } from '#core/http-notify-triggers/webhook.js';
-export { describeAgentNotifier, saveAgentNotifier, removeAgentNotifier, testAgentNotifier, listAgentPending, slackCredentialsFor, listAgentSlackChannels, type DefaultWebhook } from './web/notifier-admin.js';
+export { describeAgentNotifier, saveAgentNotifier, removeAgentNotifier, testAgentNotifier, listAgentPending, slackCredentialsFor, listAgentSlackChannels, announceToNotifier, type DefaultWebhook } from './web/notifier-admin.js';
 export type * from './core/loop-events.js';
 export { streamMessage, streamMessageWithCallbacks, sendMessage, approveCall, denyCall, answerQuestion, getSessionHistory, } from './core/client.js';
 export type { RequestOptions, SendMessageResult, PendingApprovalResult, PendingQuestionResult, PendingResult, MessageResult, StreamMessageCallbacks, } from './core/client.js';
@@ -56,7 +57,7 @@ export type { ToolSource, ComposioSourceOptions } from './core/mcpplug.js';
 export { ToolLane, buildLanes, runLanes } from './core/toollane.js';
 export type { ToolLaneOptions, SafetyClassifier, ToolCall, Lane, LaneResult } from './core/toollane.js';
 export { WebhookNotifier } from './core/http-notify-triggers/webhook.js';
-export { listQuestions, answerQuestion as resolvePendingQuestion, findQuestion, createAskUserTool } from './core/system-tools/index.js';
+export { listQuestions, answerQuestion as resolvePendingQuestion, findQuestion, createAskUserTool, createScheduleTools } from './core/system-tools/index.js';
 export type { PendingQuestion } from './core/system-tools/index.js';
 export { editAgentFile, AgentEditNotSupportedError, AgentFileNotFoundError } from './web/agent-file-admin.js';
 export type { AgentEditableFields, AgentEditResult } from './web/agent-file-admin.js';

package/dist/index.js

@@ -12,12 +12,13 @@ export { setUsageSink, recordUsage } from '#core/usage.js';
 export { readNotifierFile, writeNotifierFile, removeNotifierFile, validateNotifierFile, notifierConfigFromFile, NotifierFileError, NOTIFIER_SECRET_VARS } from '#core/notifier-file.js';
 export { listDeliveries, recordDelivery } from '#core/notifier-deliveries.js';
 export { describeNotifier } from '#core/http-notifier.js';
+export { Scheduler, ScheduleError, FileSchedulerStore, getSchedulerStore, setSchedulerStore, createScheduledTask, listScheduledTasks, getScheduledTask, cancelScheduledTask, pauseScheduledTask, resumeScheduledTask, runScheduledTaskNow, deleteScheduledTask, nextScheduledWakeAt, importLegacyScheduledTasks, parseEvery, describeSchedule } from '#core/scheduler.js';
 export { verifySlackRequest, parseSlackInteraction, openSlackAnswerModal, replyInSlack, slackOutcomeText, listSlackChannels, slackAppManifest } from '#core/slack-interactions.js';
 export { NOTIFIER_SLACK_SIGNING_SECRET_VAR } from '#core/notifier-file.js';
 export { createDecisionToken, verifyDecisionToken, decidePath, decideLinkMaker, decisionLinkTtlMs } from '#core/approval-links.js';
 export { renderDecidePage, renderDecideGonePage, renderDecideInvalidPage } from './web/decide-page.js';
 export { sendTestWebhook } from '#core/http-notify-triggers/webhook.js';
-export { describeAgentNotifier, saveAgentNotifier, removeAgentNotifier, testAgentNotifier, listAgentPending, slackCredentialsFor, listAgentSlackChannels } from './web/notifier-admin.js';
+export { describeAgentNotifier, saveAgentNotifier, removeAgentNotifier, testAgentNotifier, listAgentPending, slackCredentialsFor, listAgentSlackChannels, announceToNotifier } from './web/notifier-admin.js';
 // The framework-agnostic browser client for adapters/http.ts's own wire
 // protocol (see client.ts's own header comment) — this, not a deep
 // subpath import, is how a consumer's React/Vue/etc. chat UI is meant to
@@ -55,7 +56,7 @@ export { WebhookNotifier } from './core/http-notify-triggers/webhook.js';
 // answerQuestion above (core/client.ts) is the HTTP client-side helper —
 // this is the server-side function that actually resolves a pending
 // question in-process, aliased to avoid colliding with that name.
-export { listQuestions, answerQuestion as resolvePendingQuestion, findQuestion, createAskUserTool } from './core/system-tools/index.js';
+export { listQuestions, answerQuestion as resolvePendingQuestion, findQuestion, createAskUserTool, createScheduleTools } from './core/system-tools/index.js';
 export { editAgentFile, AgentEditNotSupportedError, AgentFileNotFoundError } from './web/agent-file-admin.js';
 export { createHttpTool, updateHttpTool, readHttpToolSpec, listEditableHttpToolNames, HttpToolNameError, HttpToolExistsError, HttpToolIndexShapeError, HttpToolNotFoundError, HttpToolNotEditableError, } from './web/http-tool-admin.js';
 export { agentsConfigPageHtml } from './web/agents-config-page.js';

package/dist/web/agents-config-page.js

@@ -39,6 +39,13 @@ export const agentsConfigPageHtml = `<!doctype html>
      panels' own content. */
   #empty { color: var(--ink-muted); font-size: 13px; padding: 24px; }
   .env-cell { display: grid; gap: 6px; }
+  .schedule-result { max-width: 420px; white-space: pre-wrap; overflow-wrap: anywhere; display: -webkit-box; -webkit-line-clamp: 3; -webkit-box-orient: vertical; overflow: hidden; font-size: 12.5px; }
+  .schedule-history { list-style: none; margin: 6px 0 0; padding: 0; display: grid; gap: 8px; }
+  form.add-source .schedule-when { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; font-size: 13px; }
+  form.add-source .schedule-when label { display: inline; font-size: 13px; }
+  form.add-source .schedule-when input[type="radio"] { width: auto; margin: 0; }
+  form.add-source .schedule-when input[type="number"] { width: 80px; }
+  form.add-source .schedule-when select, form.add-source .schedule-when input[type="datetime-local"] { width: auto; }
   .approvals-nudge { border: 1px solid var(--warn); background: var(--warn-soft); color: var(--ink); border-radius: var(--radius); padding: 12px 14px; margin-bottom: 24px; font-size: 13px; }
   .env-desc { max-width: 340px; display: -webkit-box; -webkit-line-clamp: 3; -webkit-box-orient: vertical; overflow: hidden; }
   form.add-source.env-inline { border: 0; padding: 0; display: flex; flex-wrap: wrap; gap: 6px; max-width: 320px; }
@@ -1263,6 +1270,151 @@ ${consoleShellScript}
     });
   }
 
+  // ---- Schedules tab: messages this agent receives on a timer (core/
+  // scheduler.ts behind GET/POST .../schedules and POST /schedules/:id/
+  // run|pause|resume|cancel). Reloaded every time the tab opens, and
+  // every few seconds while a run is in progress. ----
+
+  var schedulesRefreshTimer = null;
+
+  function schedulesContentEl() {
+    return detail.querySelector('#schedulesContent');
+  }
+
+  function renderSchedulesTabPlaceholder() {
+    return '<div id="schedulesContent"><p class="hint">Loading&hellip;</p></div>';
+  }
+
+  var SCHEDULE_PILLS = {
+    scheduled: 'good', running: 'accent', awaiting_approval: 'ask', paused: 'neutral', done: 'neutral', cancelled: 'neutral'
+  };
+  var SCHEDULE_LABELS = {
+    scheduled: 'scheduled', running: 'running', awaiting_approval: 'waiting for approval', paused: 'paused', done: 'done', cancelled: 'cancelled'
+  };
+
+  function scheduleText(s) {
+    return s.run_at ? 'Once, ' + new Date(s.run_at).toLocaleString() : 'Every ' + escapeHtml(s.every);
+  }
+
+  function renderScheduleRow(t) {
+    var actions = [];
+    if (t.status !== 'running' && t.status !== 'awaiting_approval' && t.status !== 'cancelled') actions.push(['run', 'Run now']);
+    if (t.status === 'scheduled') actions.push(['pause', 'Pause']);
+    if (t.status === 'paused') actions.push(['resume', 'Resume']);
+    if (t.status !== 'cancelled' && t.status !== 'done') actions.push(['cancel', 'Cancel']);
+    if (t.status === 'cancelled' || t.status === 'done') actions.push(['delete', 'Delete']);
+    var last = t.last_run_at
+      ? '<span class="le-pill ' + (t.last_status === 'ok' ? 'good' : 'bad') + '">' + escapeHtml(t.last_status) + '</span> ' +
+        '<span class="hint">' + escapeHtml(new Date(t.last_run_at).toLocaleString()) + '</span>' +
+        '<div class="schedule-result">' + escapeHtml(t.last_status === 'ok' ? (t.last_result || '') : (t.last_error || '')) + '</div>'
+      : '<span class="hint">not run yet</span>';
+    var history = (t.history || []).slice().reverse().map(function (h) {
+      return '<li><span class="le-pill ' + (h.status === 'ok' ? 'good' : 'bad') + '">' + escapeHtml(h.status) + '</span> <span class="hint">' + escapeHtml(new Date(h.ran_at).toLocaleString()) + '</span>' +
+        '<div class="schedule-result">' + escapeHtml(h.status === 'ok' ? (h.result || '') : (h.error || '')) + '</div></li>';
+    }).join('');
+    return '<tr>' +
+      '<td style="min-width:180px"><strong>' + escapeHtml(t.task_name || 'Untitled') + '</strong>' + (t.notify ? ' <span class="le-pill accent" title="Each result goes through this agent&#39;s notifier">notifies</span>' : '') +
+        '<div class="schedule-result hint">' + escapeHtml(t.message) + '</div></td>' +
+      '<td>' + scheduleText(t.schedule) + (t.next_run_at ? '<div class="hint">next ' + escapeHtml(new Date(t.next_run_at).toLocaleString()) + '</div>' : '') + '</td>' +
+      '<td><span class="le-pill ' + (SCHEDULE_PILLS[t.status] || 'neutral') + '">' + escapeHtml(SCHEDULE_LABELS[t.status] || t.status) + '</span>' +
+        (t.status === 'awaiting_approval' ? '<div class="hint"><a href="#" class="schedule-to-approvals">Decide in Permissions</a></div>' : '') + '</td>' +
+      '<td style="min-width:200px">' + last + (history ? '<details><summary class="hint">History (' + (t.history || []).length + ')</summary><ul class="schedule-history">' + history + '</ul></details>' : '') + '</td>' +
+      '<td><div style="display:flex;gap:6px;flex-wrap:wrap">' + actions.map(function (a) {
+        return '<button type="button" class="schedule-action' + (a[0] === 'run' ? ' primary' : '') + (a[0] === 'cancel' || a[0] === 'delete' ? ' delete-btn' : '') + '" data-id="' + escapeHtml(t.task_id) + '" data-action="' + a[0] + '">' + a[1] + '</button>';
+      }).join('') + '</div></td></tr>';
+  }
+
+  function renderSchedulesHtml(tasks) {
+    var active = tasks.filter(function (t) { return t.status !== 'cancelled' && t.status !== 'done'; });
+    var list = tasks.length
+      ? '<div class="le-table-wrap"><table><thead><tr><th>Task</th><th>When</th><th>Status</th><th>Last run</th><th></th></tr></thead><tbody>' + tasks.map(renderScheduleRow).join('') + '</tbody></table></div>'
+      : '<p class="hint">Nothing scheduled yet.</p>';
+    return '<p class="muted" style="margin:0 0 20px">Messages this agent receives on a timer, like a cron job. Each run works like an app calling it over HTTP: an approval goes wherever the Permissions tab sends it, and with nowhere set, a call that needs approval is denied. The agent can also schedule its own tasks when asked in Chat (&ldquo;remind me tomorrow at 9&rdquo;); they appear here too.</p>' +
+      '<section><h3>Scheduled (' + active.length + ' active)</h3>' + list + '</section>' +
+      '<section><h3>New schedule</h3>' +
+        '<form class="add-source" id="scheduleForm" style="max-width:560px">' +
+          '<label>Message <span class="hint">(what the agent receives each time, as if someone typed it)</span><textarea name="message" required placeholder="Summarize yesterday&#39;s support tickets and post the summary."></textarea></label>' +
+          '<div class="body-field">When' +
+            '<div class="schedule-when"><input type="radio" name="when" value="every" id="whenEvery" checked><label for="whenEvery">Every</label>' +
+              '<input type="number" name="everyN" value="1" min="1" aria-label="How many">' +
+              '<select name="everyUnit" aria-label="Unit"><option value="m">minutes</option><option value="h" selected>hours</option><option value="d">days</option></select></div>' +
+            '<div class="schedule-when"><input type="radio" name="when" value="once" id="whenOnce"><label for="whenOnce">Once at</label>' +
+              '<input type="datetime-local" name="runAt" aria-label="Date and time"></div>' +
+          '</div>' +
+          '<label>Name <span class="hint">(optional)</span><input name="task_name" placeholder="Daily ticket summary"></label>' +
+          '<label class="http-tool-inline-label"><input type="checkbox" name="notify"> Send each result through this agent&#39;s notifier (set in the Permissions tab)</label>' +
+          '<div style="display:flex;gap:8px"><button type="submit">Schedule</button></div>' +
+          '<div id="scheduleResult" class="hint"></div>' +
+        '</form></section>';
+  }
+
+  function wireSchedulesHandlers(name) {
+    var content = schedulesContentEl();
+    if (!content) return;
+    var actionBtns = content.querySelectorAll('.schedule-action');
+    for (var i = 0; i < actionBtns.length; i++) {
+      actionBtns[i].addEventListener('click', function (ev) {
+        var btn = ev.currentTarget;
+        var action = btn.dataset.action;
+        if ((action === 'cancel' || action === 'delete') && btn.dataset.confirming !== '1') {
+          btn.dataset.confirming = '1';
+          btn.textContent = 'Click again to ' + action;
+          return;
+        }
+        btn.disabled = true;
+        var request = action === 'delete'
+          ? fetchJsonRetryOnce('/schedules/' + encodeURIComponent(btn.dataset.id), { method: 'DELETE' })
+          : fetchJsonRetryOnce('/schedules/' + encodeURIComponent(btn.dataset.id) + '/' + action, { method: 'POST' });
+        request.then(function () { setTimeout(function () { loadSchedulesTab(name); }, action === 'run' ? 800 : 0); });
+      });
+    }
+    var toApprovals = content.querySelectorAll('.schedule-to-approvals');
+    for (var j = 0; j < toApprovals.length; j++) {
+      toApprovals[j].addEventListener('click', function (ev) { ev.preventDefault(); switchTab('actauth'); });
+    }
+    var form = content.querySelector('#scheduleForm');
+    var result = content.querySelector('#scheduleResult');
+    form.addEventListener('submit', function (ev) {
+      ev.preventDefault();
+      var data = new FormData(form);
+      var schedule;
+      if (data.get('when') === 'once') {
+        if (!data.get('runAt')) { result.textContent = 'Pick a date and time.'; return; }
+        schedule = { run_at: new Date(data.get('runAt')).toISOString() };
+      } else {
+        schedule = { every: String(data.get('everyN')) + data.get('everyUnit') };
+      }
+      result.textContent = 'Scheduling' + String.fromCharCode(8230);
+      fetchJsonRetryOnce('/agents/' + encodeURIComponent(name) + '/schedules', {
+        method: 'POST', headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ message: data.get('message'), schedule: schedule, task_name: data.get('task_name'), notify: data.get('notify') === 'on' }),
+      }).then(function (r) {
+        if (!r.ok) { result.textContent = r.body.error || 'Could not schedule'; return; }
+        loadSchedulesTab(name);
+      });
+    });
+  }
+
+  function loadSchedulesTab(name) {
+    var content = schedulesContentEl();
+    if (!content) return;
+    if (schedulesRefreshTimer) { clearTimeout(schedulesRefreshTimer); schedulesRefreshTimer = null; }
+    fetchJsonRetryOnce('/agents/' + encodeURIComponent(name) + '/schedules').then(function (r) {
+      if (currentName !== name) return;
+      if (!r.ok) throw new Error(r.body.error || 'request failed');
+      var tasks = r.body.tasks || [];
+      content.innerHTML = renderSchedulesHtml(tasks);
+      wireSchedulesHandlers(name);
+      leShell.setCount('schedules', tasks.filter(function (t) { return t.status !== 'cancelled' && t.status !== 'done'; }).length);
+      if (tasks.some(function (t) { return t.status === 'running'; }) && currentTab === 'schedules') {
+        schedulesRefreshTimer = setTimeout(function () { loadSchedulesTab(name); }, 3000);
+      }
+    }).catch(function (err) {
+      if (currentName !== name) return;
+      content.innerHTML = '<p class="error">Could not load schedules: ' + escapeHtml(err.message) + '</p>';
+    });
+  }
+
   function actauthContentEl() {
     return detail.querySelector('#actauthContent');
   }
@@ -2737,7 +2889,7 @@ ${consoleShellScript}
 
   // ---- Tab switching + agent selection ----
 
-  var CONFIG_TABS = ['overview', 'tools', 'skills', 'abilities', 'actauth', 'env'];
+  var CONFIG_TABS = ['overview', 'tools', 'skills', 'abilities', 'actauth', 'schedules', 'env'];
 
   function switchTab(tab) {
     if (CONFIG_TABS.indexOf(tab) === -1) tab = 'overview';
@@ -2765,6 +2917,7 @@ ${consoleShellScript}
     if (tab === 'abilities' && abilitiesLoadedFor !== currentName) {
       loadAbilitiesTab(currentName);
     }
+    if (tab === 'schedules') loadSchedulesTab(currentName);
   }
 
   // Refreshes just Overview's own summary — used after anything that
@@ -2861,6 +3014,7 @@ ${consoleShellScript}
       '<div class="tab-panel" data-tab-panel="actauth">' + renderActauthTabPlaceholder() + '</div>' +
       '<div class="tab-panel" data-tab-panel="env">' + renderEnvTabPlaceholder() + '</div>' +
       '<div class="tab-panel" data-tab-panel="abilities">' + renderAbilitiesTabPlaceholder() + '</div>' +
+      '<div class="tab-panel" data-tab-panel="schedules">' + renderSchedulesTabPlaceholder() + '</div>' +
       '</div></div>';
 
     wireSkillsHandlers(cfg.name);

package/dist/web/console-shell.js

@@ -42,7 +42,7 @@ export const consoleShellScript = `<script>
   var toSet = {};
   var TABS = [
     ['chat', 'Chat'], ['overview', 'Overview'], ['abilities', 'Abilities'], ['tools', 'Tools'],
-    ['skills', 'Skills'], ['actauth', 'Permissions'], ['env', 'Environment']
+    ['skills', 'Skills'], ['actauth', 'Permissions'], ['schedules', 'Schedules'], ['env', 'Environment']
   ];
 
   function esc(s) {

package/dist/web/notifier-admin.d.ts

@@ -1,6 +1,7 @@
 import type { AgentConfig } from '../core/agent-config.js';
 import type { CheckpointStore } from '../core/durable-approvals.js';
 import { type DeliveryResult } from '../core/http-notify-triggers/webhook.js';
+import type { HttpNotifierConfig } from '../core/agent-config.js';
 import { type NotifierFileChannel } from '../core/notifier-file.js';
 import { type SlackChannel } from '../core/slack-interactions.js';
 /** The deployment-wide default webhook (LOOPENGINE_DEFAULT_WEBHOOK_URL /
@@ -25,7 +26,7 @@ export declare function describeAgentNotifier(config: AgentConfig, defaultWebhoo
         manifestTemplate: Record<string, unknown>;
     };
     deliveries: import("../core/notifier-deliveries.js").NotifierDelivery[];
-    channel?: import("../core/agent-config.js").HttpNotifierConfig["channel"];
+    channel?: HttpNotifierConfig["channel"];
     events?: string[];
     file?: import("../core/notifier-file.js").NotifierFile;
     missingSecret?: string;
@@ -49,6 +50,11 @@ export declare function listAgentSlackChannels(config: AgentConfig, botToken?: s
 /** Removes notifier.yml; the stored secret is left alone, so turning the
  * notifier back on doesn't need it re-entered. */
 export declare function removeAgentNotifier(config: AgentConfig): void;
+/** Posts a plain announcement through the agent's notifier — a scheduled
+ * task's result, for one — regardless of which events it subscribed to.
+ * A webhook gets a signed `run_finish` payload with `data` merged in;
+ * Slack and Lark get `text`. Does nothing when no notifier applies. */
+export declare function announceToNotifier(config: AgentConfig, text: string, data: Record<string, unknown>, defaultWebhook?: DefaultWebhook): boolean;
 /** Sends a test through whichever notifier applies to this agent —
  * webhook or Slack; reports what the receiver answered. */
 export declare function testAgentNotifier(config: AgentConfig, defaultWebhook?: DefaultWebhook): Promise<DeliveryResult & {

package/dist/web/notifier-admin.js

@@ -2,7 +2,9 @@ import { agentDirFor, createAgentEnv } from '../core/agent-env.js';
 import { decidePath } from '../core/approval-links.js';
 import { describeNotifier } from '../core/http-notifier.js';
 import { sendTestSlackMessage } from '../core/http-notify-triggers/slack.js';
-import { sendTestWebhook } from '../core/http-notify-triggers/webhook.js';
+import { postLifecycleWebhook, sendTestWebhook } from '../core/http-notify-triggers/webhook.js';
+import { SlackNotifier } from '../core/http-notify-triggers/slack.js';
+import { LarkNotifier } from '../core/http-notify-triggers/lark.js';
 import { listDeliveries } from '../core/notifier-deliveries.js';
 import { NOTIFIER_SECRET_VARS, NOTIFIER_SLACK_SIGNING_SECRET_VAR, notifierConfigFromFile, readNotifierFile, removeNotifierFile, writeNotifierFile } from '../core/notifier-file.js';
 import { listSlackChannels, slackAppManifest } from '../core/slack-interactions.js';
@@ -65,6 +67,49 @@ export async function listAgentSlackChannels(config, botToken) {
 export function removeAgentNotifier(config) {
     removeNotifierFile(agentDirFor(config));
 }
+/** The notifier settings that apply to an agent: its code httpNotifier,
+ * else its notifier.yml (once its secret is set), else the
+ * deployment-wide default webhook. */
+function activeNotifierTarget(config, defaultWebhook) {
+    if (config.httpNotifier)
+        return config.httpNotifier;
+    const dir = agentDirFor(config);
+    const file = readNotifierFile(dir);
+    if (file) {
+        const { config: fromFile } = notifierConfigFromFile(file, createAgentEnv(config.name, dir));
+        if (fromFile)
+            return fromFile;
+    }
+    return defaultWebhook ? { channel: 'webhook', config: { webhookUrl: defaultWebhook.webhookUrl, webhookSecret: defaultWebhook.webhookSecret }, events: ['run_finish'] } : undefined;
+}
+/** Posts a plain announcement through the agent's notifier — a scheduled
+ * task's result, for one — regardless of which events it subscribed to.
+ * A webhook gets a signed `run_finish` payload with `data` merged in;
+ * Slack and Lark get `text`. Does nothing when no notifier applies. */
+export function announceToNotifier(config, text, data, defaultWebhook) {
+    let target;
+    try {
+        target = activeNotifierTarget(config, defaultWebhook);
+    }
+    catch {
+        return false;
+    }
+    if (!target)
+        return false;
+    switch (target.channel) {
+        case 'webhook':
+            postLifecycleWebhook(target.config.webhookUrl, target.config.webhookSecret, 'run_finish', { agent: config.name, text, ...data });
+            return true;
+        case 'slack':
+            new SlackNotifier({ botToken: target.config.botToken, channelId: target.config.channelId }).postMessage(text);
+            return true;
+        case 'lark':
+            new LarkNotifier({ appId: target.config.appId, appSecret: target.config.appSecret, chatId: target.config.chatId }).postMessage(text);
+            return true;
+        default:
+            return false;
+    }
+}
 /** Sends a test through whichever notifier applies to this agent —
  * webhook or Slack; reports what the receiver answered. */
 export async function testAgentNotifier(config, defaultWebhook) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loopengine",
-  "version": "0.1.69",
+  "version": "0.1.70",
   "type": "module",
   "description": "Runtime for tool-using AI agents with a transparent ReAct loop.",
   "license": "MIT",
@@ -52,6 +52,8 @@
     "dist/core/approval-links.d.ts",
     "dist/core/slack-interactions.js",
     "dist/core/slack-interactions.d.ts",
+    "dist/core/scheduler.js",
+    "dist/core/scheduler.d.ts",
     "dist/core/session-store.js",
     "dist/core/session-store.d.ts",
     "dist/core/vector-index.js",
@@ -102,7 +104,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsc; s=$?; chmod +x dist/bin/cli.js; cp -r core/system-skills dist/core/system-skills; tsx scripts/write-dist-package-json.ts; exit $s",
+    "build": "tsc; s=$?; chmod +x dist/bin/cli.js; rm -rf dist/core/system-skills; cp -r core/system-skills dist/core/system-skills; tsx scripts/write-dist-package-json.ts; exit $s",
     "prepublishOnly": "npm run build",
     "start": "node --env-file-if-exists=.env dist/adapters/http.js",
     "test": "vitest run"