loopengine 0.1.68 → 0.1.70

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,10 +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, 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';
@@ -54,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,10 +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 } 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
@@ -53,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; }
@@ -962,6 +969,7 @@ ${consoleShellScript}
   // deliveries. Reloaded every time the tab opens, so the waiting list is
   // current. ----
 
+  var lastNotifier = null;
   var NOTIFIER_EVENTS = [
     ['approval', 'Approvals'], ['question', 'Questions'], ['run_finish', 'Run finished'], ['run_start', 'Run started']
   ];
@@ -1017,8 +1025,27 @@ ${consoleShellScript}
       '<label>Send to<select name="channel" id="notifierChannel">' +
         ['webhook', 'slack', 'lark'].map(function (c) { return '<option value="' + c + '"' + (f.channel === c ? ' selected' : '') + '>' + { webhook: 'Webhook (your app)', slack: 'Slack channel', lark: 'Lark / Feishu chat' }[c] + '</option>'; }).join('') +
       '</select></label>' +
-      field('webhook', '<label>Webhook URL<input type="url" name="url" placeholder="https://your-app.example.com/hooks/loopengine" value="' + escapeHtml(f.url || '') + '"></label>' + secretField('webhook', 'Signing secret')) +
-      field('slack', '<label>Channel ID<input name="channelId" placeholder="C0123ABC456" value="' + escapeHtml(f.channelId || '') + '"></label>' + secretField('slack', 'Bot token')) +
+      field('webhook', '<label>Webhook URL<input type="url" name="url" placeholder="https://your-app.example.com/hooks/loopengine" value="' + escapeHtml(f.url || '') + '"></label>' + secretField('webhook', 'Signing secret') +
+        '<p class="hint" style="margin:0">Your app checks the <code>X-Actauth-Signature</code> header (HMAC-SHA256 of the body with the signing secret). Each payload carries a <code>decideUrl</code> it can simply forward to a person, or it can decide itself by sending <code>{"decision":"approve"}</code> or <code>{"decision":"deny"}</code> to <code>resolveUrl</code>.</p>') +
+      field('slack',
+        '<details class="slack-step"' + (n.secretsSet && n.secretsSet.slack ? '' : ' open') + '><summary>Create the Slack app (once)</summary>' +
+          '<ol class="hint" style="margin:6px 0;padding-left:18px">' +
+            '<li>Open <a href="https://api.slack.com/apps?new_app=1" target="_blank" rel="noopener">Slack apps</a> &rarr; Create New App &rarr; From a manifest, and pick your workspace.</li>' +
+            '<li>Paste the manifest below, create the app, then Install to Workspace.</li>' +
+            '<li>Copy the <strong>Bot User OAuth Token</strong> (starts with xoxb-) from OAuth &amp; Permissions into the field below.</li>' +
+          '</ol>' +
+          '<textarea id="slackManifest" readonly rows="8" style="font-family:var(--font-mono);font-size:11.5px"></textarea>' +
+          '<button type="button" id="slackManifestCopy" style="margin-top:6px">Copy manifest</button>' +
+        '</details>' +
+        secretField('slack', 'Bot token') +
+        '<label>Channel <span class="hint">(invite the bot to a private channel first: /invite @its-name)</span>' +
+          '<span style="display:flex;gap:6px"><select id="slackChannelSelect" style="flex:1;min-width:0"><option value="">' + (f.channelId ? 'Saved: ' + escapeHtml(f.channelId) : 'Load channels to pick one') + '</option></select>' +
+          '<button type="button" id="slackLoadChannels">Load channels</button></span></label>' +
+        '<label>Channel ID <span class="hint">(filled in when you pick a channel)</span><input name="channelId" placeholder="C0123ABC456" value="' + escapeHtml(f.channelId || '') + '"></label>' +
+        '<label>Signing secret <span class="hint">(optional, from Basic Information; ' +
+          (n.slack && n.slack.signingSecretSet ? 'set &mdash; Approve/Deny buttons are on' : 'adds Approve/Deny buttons inside Slack; without it, messages carry the approval link') + ')</span>' +
+          '<input type="password" name="signingSecret" autocomplete="off"></label>' +
+        '<p class="hint" style="margin:0">Buttons send their clicks to <code id="slackInteractivityUrl"></code> (the manifest already points there).</p>') +
       field('lark', '<label>App ID<input name="appId" value="' + escapeHtml(f.appId || '') + '"></label><label>Chat ID<input name="chatId" value="' + escapeHtml(f.chatId || '') + '"></label>' + secretField('lark', 'App secret')) +
       '<label>Link address <span class="hint">(messages link here so people can approve without logging in; use an address they can reach)</span>' +
         '<input type="url" name="publicUrl" id="notifierPublicUrl" value="' + escapeHtml(n.publicUrl || f.publicUrl || location.origin) + '"' + (n.publicUrl ? ' disabled title="Set by LOOPENGINE_PUBLIC_URL"' : '') + '></label>' +
@@ -1031,7 +1058,7 @@ ${consoleShellScript}
       '<div style="display:flex;gap:8px;flex-wrap:wrap"><button type="submit"' + (n.canSave === false ? ' disabled' : '') + '>Save</button><button type="button" id="notifierTestBtn">Send test</button>' +
         (n.file ? '<button type="button" class="delete-btn" id="notifierRemoveBtn">Remove</button>' : '') + '</div>' +
       '<div id="notifierResult" class="hint"></div>' +
-      '<p class="hint" style="margin:0">For a webhook: your app checks the <code>X-Actauth-Signature</code> header (HMAC-SHA256 of the body with the signing secret). Each payload carries a <code>decideUrl</code> it can simply forward to a person, or it can decide itself by sending <code>{"decision":"approve"}</code> or <code>{"decision":"deny"}</code> to <code>resolveUrl</code>.</p>' +
+
       '</form>';
   }
 
@@ -1142,6 +1169,51 @@ ${consoleShellScript}
         result.textContent = 'Copy this secret into your app before saving; it is not shown again.';
       });
     }
+    // Slack: manifest follows the link address; Load channels fills the picker.
+    var n0 = lastNotifier;
+    var manifestEl = form.querySelector('#slackManifest');
+    var linkInput = form.querySelector('#notifierPublicUrl');
+    function refreshSlackManifest() {
+      if (!manifestEl || !n0 || !n0.slack) return;
+      var url = (linkInput.value || location.origin).replace(/[/]+$/, '') + n0.slack.interactivityPath;
+      manifestEl.value = JSON.stringify(n0.slack.manifestTemplate, null, 2).replace('__INTERACTIVITY_URL__', url);
+      var urlEl = form.querySelector('#slackInteractivityUrl');
+      if (urlEl) urlEl.textContent = url;
+    }
+    if (linkInput) linkInput.addEventListener('input', refreshSlackManifest);
+    refreshSlackManifest();
+    var copyManifest = form.querySelector('#slackManifestCopy');
+    if (copyManifest) {
+      copyManifest.addEventListener('click', function () {
+        manifestEl.select();
+        var done = function () { copyManifest.textContent = 'Copied'; setTimeout(function () { copyManifest.textContent = 'Copy manifest'; }, 1500); };
+        if (navigator.clipboard) navigator.clipboard.writeText(manifestEl.value).then(done, done); else done();
+      });
+    }
+    var loadChannels = form.querySelector('#slackLoadChannels');
+    var channelSelect = form.querySelector('#slackChannelSelect');
+    if (loadChannels) {
+      loadChannels.addEventListener('click', function () {
+        loadChannels.disabled = true;
+        result.textContent = 'Loading channels' + String.fromCharCode(8230);
+        var token = form.querySelector('input[name="secret_slack"]').value;
+        fetchJsonRetryOnce('/agents/' + encodeURIComponent(name) + '/notifier/slack-channels', {
+          method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ botToken: token }),
+        }).then(function (r) {
+          loadChannels.disabled = false;
+          if (!r.ok) { result.textContent = r.body.error || 'Could not load channels'; return; }
+          var current = form.querySelector('input[name="channelId"]').value;
+          channelSelect.innerHTML = '<option value="">Pick a channel</option>' + r.body.channels.map(function (c) {
+            return '<option value="' + escapeHtml(c.id) + '"' + (c.id === current ? ' selected' : '') + '>' + (c.isPrivate ? '&#128274; ' : '#') + escapeHtml(c.name) + (c.isMember ? '' : ' (bot not in channel yet)') + '</option>';
+          }).join('');
+          result.textContent = r.body.channels.length + ' channels found.';
+        });
+      });
+      channelSelect.addEventListener('change', function () {
+        if (channelSelect.value) form.querySelector('input[name="channelId"]').value = channelSelect.value;
+      });
+    }
+
     form.addEventListener('submit', function (ev) {
       ev.preventDefault();
       var data = new FormData(form);
@@ -1149,6 +1221,7 @@ ${consoleShellScript}
       var body = { channel: channel, events: data.getAll('events'), url: data.get('url'), channelId: data.get('channelId'), appId: data.get('appId'), chatId: data.get('chatId'), publicUrl: data.get('publicUrl') };
       var secret = data.get('secret_' + channel);
       if (secret) body.secret = secret;
+      if (channel === 'slack' && data.get('signingSecret')) body.signingSecret = data.get('signingSecret');
       result.textContent = 'Saving…';
       fetchJsonRetryOnce('/agents/' + encodeURIComponent(name) + '/notifier', {
         method: 'PUT', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body),
@@ -1182,6 +1255,7 @@ ${consoleShellScript}
     ]).then(function (results) {
       if (currentName !== name) return;
       if (!results[0].ok) throw new Error(results[0].body.error || 'request failed');
+      lastNotifier = results[0].body;
       content.innerHTML = renderApprovalsHtml(results[0].body);
       wireApprovalsHandlers(name);
       var pendingEl = detail.querySelector('#pendingContent');
@@ -1196,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');
   }
@@ -2670,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';
@@ -2698,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
@@ -2794,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,7 +1,9 @@
 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 /
  * _SECRET), which applies to the plain /messages route when an agent has
  * no notifier of its own. */
@@ -17,8 +19,14 @@ export declare function describeAgentNotifier(config: AgentConfig, defaultWebhoo
     secretsSet: {
         [k: string]: boolean;
     };
+    slack: {
+        signingSecretVar: string;
+        signingSecretSet: boolean;
+        interactivityPath: string;
+        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;
@@ -28,9 +36,25 @@ export declare function describeAgentNotifier(config: AgentConfig, defaultWebhoo
  * form includes one, the channel's secret into the agent's own env.
  * Throws NotifierFileError for an invalid form. */
 export declare function saveAgentNotifier(config: AgentConfig, body: Record<string, unknown>): Promise<void>;
+/** The bot token and signing secret behind an agent's Slack notifier —
+ * from AgentConfig.httpNotifier when it's Slack, else from the agent's
+ * env (the console-saved ones). The signing secret always comes from the
+ * agent env. */
+export declare function slackCredentialsFor(config: AgentConfig): {
+    botToken?: string;
+    signingSecret?: string;
+};
+/** Channels for the console's picker, with the token being typed in or,
+ * when none is given, the one already saved. */
+export declare function listAgentSlackChannels(config: AgentConfig, botToken?: string): Promise<SlackChannel[]>;
 /** 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 & {