loopengine 0.1.67 → 0.1.69

package/dist/core/slack-interactions.d.ts

@@ -0,0 +1,59 @@
+export declare const SLACK_ANSWER_BLOCK_ID = "answer_block";
+export declare const SLACK_ANSWER_ACTION_ID = "answer_input";
+/** https://api.slack.com/authentication/verifying-requests-from-slack —
+ * rejects anything older than five minutes, so a captured request can't
+ * be replayed later. */
+export declare function verifySlackRequest(rawBody: string, timestamp: string | undefined, signature: string | undefined, signingSecret: string, nowMs?: number): boolean;
+export type SlackInteraction = {
+    type: 'decide';
+    pendingId: string;
+    decision: 'approve' | 'deny';
+    responseUrl?: string;
+    user?: string;
+} | {
+    type: 'answer';
+    pendingId: string;
+    answer: string;
+    responseUrl?: string;
+    user?: string;
+} | {
+    type: 'open_answer';
+    pendingId: string;
+    triggerId: string;
+} | {
+    type: 'ignore';
+};
+/** Reads Slack's form-encoded `payload=<json>` body into the one thing
+ * it asks for. Anything unrecognized is `ignore`. */
+export declare function parseSlackInteraction(rawBody: string): SlackInteraction;
+/** Opens the free-text answer modal for "Other…". Slack's trigger_id
+ * expires three seconds after the click, so call this before anything slow. */
+export declare function openSlackAnswerModal(botToken: string, triggerId: string, pendingId: string): Promise<void>;
+/** Replaces the original message (its buttons included) with what
+ * happened, so nobody clicks a decision that's already made. */
+export declare function replyInSlack(responseUrl: string, text: string): Promise<void>;
+/** What to say in Slack after a decision, from the resolve route's own
+ * response body. */
+export declare function slackOutcomeText(kind: 'approve' | 'deny' | 'answer', status: number, body: {
+    alreadyResolved?: boolean;
+    resolved?: boolean;
+    text?: string;
+    error?: string;
+    pending?: unknown[];
+}, user?: string): string;
+export interface SlackChannel {
+    id: string;
+    name: string;
+    isPrivate: boolean;
+    isMember: boolean;
+}
+/** Channels the bot can see — needs the channels:read (and, for private
+ * channels, groups:read) scope. */
+export declare function listSlackChannels(botToken: string): Promise<SlackChannel[]>;
+/** A Slack app manifest for one agent's notifier: a bot that can post and
+ * read the channel list, with interactivity pointed at this server.
+ * Paste it into api.slack.com/apps → Create New App → From a manifest. */
+export declare function slackAppManifest(options: {
+    agentName: string;
+    interactivityUrl: string;
+}): Record<string, unknown>;

package/dist/core/slack-interactions.js

@@ -0,0 +1,168 @@
+// What the server needs to handle Slack button clicks itself (POST
+// /hooks/slack/<agent> in adapters/http.ts), so a Slack notifier's
+// Approve/Deny and answer buttons work with no handler of your own to
+// deploy: request verification, reading the interaction payload, the
+// "Other…" answer modal, replying in the original message, listing
+// channels for the console's channel picker, and the app manifest the
+// console shows for creating the Slack app.
+//
+// Same button contract SlackNotifier (core/http-notify-triggers/slack.ts)
+// sends: action_id approve|deny with the pendingId as value,
+// answer_option with {pendingId, answer}, open_answer_modal with the
+// pendingId, and the modal's answer under ANSWER_BLOCK_ID/ANSWER_ACTION_ID.
+import { createHmac, timingSafeEqual } from 'node:crypto';
+export const SLACK_ANSWER_BLOCK_ID = 'answer_block';
+export const SLACK_ANSWER_ACTION_ID = 'answer_input';
+/** https://api.slack.com/authentication/verifying-requests-from-slack —
+ * rejects anything older than five minutes, so a captured request can't
+ * be replayed later. */
+export function verifySlackRequest(rawBody, timestamp, signature, signingSecret, nowMs = Date.now()) {
+    if (!timestamp || !signature)
+        return false;
+    const age = Math.abs(nowMs / 1000 - Number(timestamp));
+    if (!Number.isFinite(age) || age > 60 * 5)
+        return false;
+    const expected = Buffer.from(`v0=${createHmac('sha256', signingSecret).update(`v0:${timestamp}:${rawBody}`).digest('hex')}`);
+    const actual = Buffer.from(signature);
+    return expected.length === actual.length && timingSafeEqual(expected, actual);
+}
+/** Reads Slack's form-encoded `payload=<json>` body into the one thing
+ * it asks for. Anything unrecognized is `ignore`. */
+export function parseSlackInteraction(rawBody) {
+    const raw = new URLSearchParams(rawBody).get('payload');
+    if (!raw)
+        return { type: 'ignore' };
+    let payload;
+    try {
+        payload = JSON.parse(raw);
+    }
+    catch {
+        return { type: 'ignore' };
+    }
+    const user = payload.user?.id;
+    if (payload.type === 'view_submission' && payload.view?.private_metadata) {
+        const answer = payload.view.state?.values?.[SLACK_ANSWER_BLOCK_ID]?.[SLACK_ANSWER_ACTION_ID]?.value ?? '';
+        return { type: 'answer', pendingId: payload.view.private_metadata, answer, user };
+    }
+    if (payload.type !== 'block_actions')
+        return { type: 'ignore' };
+    const action = payload.actions?.[0];
+    if (!action?.value)
+        return { type: 'ignore' };
+    switch (action.action_id) {
+        case 'approve':
+        case 'deny':
+            return { type: 'decide', pendingId: action.value, decision: action.action_id, responseUrl: payload.response_url, user };
+        case 'answer_option': {
+            try {
+                const { pendingId, answer } = JSON.parse(action.value);
+                return pendingId && typeof answer === 'string' ? { type: 'answer', pendingId, answer, responseUrl: payload.response_url, user } : { type: 'ignore' };
+            }
+            catch {
+                return { type: 'ignore' };
+            }
+        }
+        case 'open_answer_modal':
+            return payload.trigger_id ? { type: 'open_answer', pendingId: action.value, triggerId: payload.trigger_id } : { type: 'ignore' };
+        default:
+            return { type: 'ignore' };
+    }
+}
+/** Opens the free-text answer modal for "Other…". Slack's trigger_id
+ * expires three seconds after the click, so call this before anything slow. */
+export async function openSlackAnswerModal(botToken, triggerId, pendingId) {
+    const res = await fetch('https://slack.com/api/views.open', {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${botToken}`, 'content-type': 'application/json; charset=utf-8' },
+        body: JSON.stringify({
+            trigger_id: triggerId,
+            view: {
+                type: 'modal',
+                callback_id: 'answer_modal',
+                private_metadata: pendingId,
+                title: { type: 'plain_text', text: 'Your answer' },
+                submit: { type: 'plain_text', text: 'Send' },
+                blocks: [
+                    {
+                        type: 'input',
+                        block_id: SLACK_ANSWER_BLOCK_ID,
+                        label: { type: 'plain_text', text: 'Answer' },
+                        element: { type: 'plain_text_input', action_id: SLACK_ANSWER_ACTION_ID, multiline: true },
+                    },
+                ],
+            },
+        }),
+    });
+    const body = (await res.json());
+    if (!body.ok)
+        throw new Error(`views.open failed: ${body.error}`);
+}
+/** Replaces the original message (its buttons included) with what
+ * happened, so nobody clicks a decision that's already made. */
+export async function replyInSlack(responseUrl, text) {
+    await fetch(responseUrl, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ replace_original: true, text }),
+    });
+}
+/** What to say in Slack after a decision, from the resolve route's own
+ * response body. */
+export function slackOutcomeText(kind, status, body, user) {
+    const who = user ? ` by <@${user}>` : '';
+    if (status >= 400)
+        return `:warning: Couldn't record that: ${body.error ?? `HTTP ${status}`}`;
+    if (body.alreadyResolved)
+        return 'Already decided elsewhere.';
+    const what = kind === 'approve' ? ':white_check_mark: Approved' : kind === 'deny' ? ':no_entry: Denied' : ':speech_balloon: Answered';
+    if (body.resolved)
+        return `${what}${who}. Still waiting on another decision in the same turn.`;
+    if (body.pending?.length)
+        return `${what}${who}. The agent needs another decision; a new message is on its way.`;
+    return `${what}${who}.${body.text ? `\n>${body.text.replace(/\n/g, '\n>')}` : ''}`;
+}
+/** Channels the bot can see — needs the channels:read (and, for private
+ * channels, groups:read) scope. */
+export async function listSlackChannels(botToken) {
+    const channels = [];
+    let cursor = '';
+    for (let page = 0; page < 10; page++) {
+        const params = new URLSearchParams({ types: 'public_channel,private_channel', exclude_archived: 'true', limit: '200' });
+        if (cursor)
+            params.set('cursor', cursor);
+        const res = await fetch(`https://slack.com/api/conversations.list?${params}`, { headers: { Authorization: `Bearer ${botToken}` } });
+        const body = (await res.json());
+        if (!body.ok) {
+            const reasons = {
+                missing_scope: 'The bot token is missing the channels:read scope; reinstall the app from the manifest',
+                invalid_auth: 'Slack rejected the bot token; copy the Bot User OAuth Token (xoxb-...) again',
+                not_authed: 'Enter the bot token first',
+                token_revoked: 'This bot token was revoked; reinstall the app and copy the new one',
+            };
+            throw new Error(reasons[body.error ?? ''] ?? `Slack said: ${body.error}`);
+        }
+        for (const c of body.channels ?? [])
+            channels.push({ id: c.id, name: c.name, isPrivate: Boolean(c.is_private), isMember: Boolean(c.is_member) });
+        cursor = body.response_metadata?.next_cursor ?? '';
+        if (!cursor)
+            break;
+    }
+    return channels.sort((a, b) => Number(b.isMember) - Number(a.isMember) || a.name.localeCompare(b.name));
+}
+/** A Slack app manifest for one agent's notifier: a bot that can post and
+ * read the channel list, with interactivity pointed at this server.
+ * Paste it into api.slack.com/apps → Create New App → From a manifest. */
+export function slackAppManifest(options) {
+    const name = `LoopEngine ${options.agentName}`.slice(0, 35);
+    return {
+        display_information: { name, description: `Approval requests and questions from the ${options.agentName} agent` },
+        features: { bot_user: { display_name: name, always_online: true } },
+        oauth_config: { scopes: { bot: ['chat:write', 'channels:read', 'groups:read'] } },
+        settings: {
+            interactivity: { is_enabled: true, request_url: options.interactivityUrl },
+            org_deploy_enabled: false,
+            socket_mode_enabled: false,
+            token_rotation_enabled: false,
+        },
+    };
+}

package/dist/index.d.ts

@@ -10,8 +10,12 @@ 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 { 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, 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';

package/dist/index.js

@@ -12,8 +12,12 @@ 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 { 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 } 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

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

@@ -39,6 +39,7 @@ export const agentsConfigPageHtml = `<!doctype html>
      panels' own content. */
   #empty { color: var(--ink-muted); font-size: 13px; padding: 24px; }
   .env-cell { display: grid; gap: 6px; }
+  .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; }
   form.add-source.env-inline input, form.add-source.env-inline select { flex: 1 1 140px; width: auto; min-width: 0; }
@@ -955,12 +956,13 @@ ${consoleShellScript}
         '</form></section>';
   }
 
-  // ---- Permissions → Approvals: where "ask" decisions go when nobody is
+  // ---- Permissions → "Where approval requests and questions are sent": where "ask" decisions go when nobody is
   // in Chat (web/notifier-admin.ts behind GET/PUT/DELETE .../notifier),
   // the decisions still waiting (GET .../pending), and recent webhook
   // 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']
   ];
@@ -980,6 +982,9 @@ ${consoleShellScript}
           ? '<form class="pending-answer" data-id="' + escapeHtml(p.pendingId) + '" style="display:flex;gap:6px"><input name="answer" placeholder="Answer" required style="min-width:0"><button type="submit">Answer</button></form>'
           : '<div style="display:flex;gap:6px"><button type="button" class="primary pending-decide" data-id="' + escapeHtml(p.pendingId) + '" data-decision="approve">Approve</button>' +
             '<button type="button" class="pending-decide" data-id="' + escapeHtml(p.pendingId) + '" data-decision="deny">Deny</button></div>';
+        if (p.decidePath) {
+          actions += '<button type="button" class="pending-copy" data-path="' + escapeHtml(p.decidePath) + '" title="A link anyone can open to decide, no login needed" style="margin-top:6px">Copy link</button>';
+        }
         return '<tr><td><span class="le-pill ' + (p.kind === 'question' ? 'accent' : 'ask') + '">' + (p.kind === 'question' ? 'question' : 'approval') + '</span>' +
           (p.createdAt ? '<div class="hint">' + escapeHtml(new Date(p.createdAt).toLocaleString()) + '</div>' : '') + '</td>' +
           '<td>' + details + '</td><td><code>' + escapeHtml(p.sessionId) + '</code></td><td>' + actions + '</td></tr>';
@@ -991,12 +996,15 @@ ${consoleShellScript}
     if (n.source === 'file') return 'Sending to <strong>' + escapeHtml(n.channel) + '</strong> for: ' + escapeHtml((n.events || []).join(', ')) + '.';
     if (n.missingSecret) return 'Saved, but not sending yet: set the secret below (<code>' + escapeHtml(n.missingSecret) + '</code>).';
     if (n.source === 'default') return 'Using the project-wide default webhook (<code>LOOPENGINE_DEFAULT_WEBHOOK_URL</code>, ' + escapeHtml(n.defaultWebhookUrl) + '). Set one below to use a different target for this agent.';
-    return 'Not set up. A call that needs approval only reaches someone in Chat; set a webhook or Slack channel so apps calling this agent over HTTP can get approvals.';
+    return '<strong>Nowhere yet</strong>, so nobody is notified. Choose a webhook, Slack channel or Lark chat below.';
   }
 
   function renderNotifierForm(n) {
     var f = n.file || { channel: 'webhook', events: ['approval', 'question'] };
     var events = f.events || [];
+    function eventBox(e) {
+      return '<label class="tool-picker-item" style="border:0;padding:0;justify-content:flex-start"><input type="checkbox" name="events" value="' + e[0] + '"' + (events.indexOf(e[0]) !== -1 ? ' checked' : '') + '> ' + e[1] + '</label>';
+    }
     function field(channel, html) {
       return '<div class="notifier-fields" data-channel="' + channel + '"' + (f.channel === channel ? '' : ' hidden') + '>' + html + '</div>';
     }
@@ -1010,18 +1018,40 @@ ${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')) +
-      '<div class="body-field">Send<div style="display:flex;gap:14px;flex-wrap:wrap">' +
-        NOTIFIER_EVENTS.map(function (e) {
-          return '<label class="tool-picker-item" style="border:0;padding:0;justify-content:flex-start"><input type="checkbox" name="events" value="' + e[0] + '"' + (events.indexOf(e[0]) !== -1 ? ' checked' : '') + '> ' + e[1] + '</label>';
-        }).join('') + '</div></div>' +
-      '<div style="display:flex;gap:8px;flex-wrap:wrap"><button type="submit">Save</button><button type="button" id="notifierTestBtn">Send test</button>' +
+      '<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>' +
+      '<div class="body-field">Send' +
+        '<div style="display:flex;gap:14px;flex-wrap:wrap">' + NOTIFIER_EVENTS.slice(0, 2).map(eventBox).join('') + '</div>' +
+        '<details' + (events.indexOf('run_finish') !== -1 || events.indexOf('run_start') !== -1 ? ' open' : '') + '><summary>More events</summary>' +
+        '<div style="display:flex;gap:14px;flex-wrap:wrap;margin-top:6px">' + NOTIFIER_EVENTS.slice(2).map(eventBox).join('') + '</div>' +
+        '<p class="hint" style="margin:4px 0 0">Run finished tells your app the agent&#39;s final reply once a decision lets it finish.</p></details></div>' +
+      (n.canSave === false ? '<p class="error" style="margin:0">Saving needs <code>LOOPENGINE_ADMIN_AUTH</code> set on the server, because this stores a secret. Add <code>LOOPENGINE_ADMIN_AUTH=user:pass</code> to <code>.env</code> and restart.</p>' : '') +
+      '<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">Your app checks the <code>X-Actauth-Signature</code> header (HMAC-SHA256 of the body with the signing secret). Each payload carries <code>pendingId</code> and <code>resolvePath</code>; your app sends <code>{"decision":"approve"}</code> or <code>{"decision":"deny"}</code> there.' +
-        (n.publicUrl ? '' : ' Set <code>LOOPENGINE_PUBLIC_URL</code> to include a full <code>resolveUrl</code> too.') + '</p>' +
+
       '</form>';
   }
 
@@ -1034,14 +1064,35 @@ ${consoleShellScript}
       }).join('') + '</tbody></table></div>';
   }
 
-  // Shown at the top of the tab, and only when something is waiting.
-  function renderPendingHtml(pending) {
-    if (!pending.length) return '';
-    return '<section><h3>Waiting for a decision (' + pending.length + ')</h3>' + renderPendingTable(pending) + '</section>';
+  // Tools that can stop for approval: a rule that asks, or "ask" as the
+  // decision when no rule matches.
+  function askingTools() {
+    var perms = currentCfg && currentCfg.permissions;
+    if (!perms) return [];
+    var tools = [];
+    perms.rules.forEach(function (r) { if (r.decision === 'ask' && tools.indexOf(r.tool) === -1) tools.push(r.tool); });
+    if (perms.defaultDecision === 'ask') tools.push('any tool without a rule');
+    return tools;
+  }
+
+  // The top of the tab: a nudge when approvals over HTTP would reach
+  // nobody, and whatever is waiting right now.
+  function renderPendingHtml(pending, n) {
+    var html = '';
+    var tools = askingTools();
+    if (tools.length && n && n.source === 'none') {
+      html += '<div class="approvals-nudge"><strong>Approval requests aren&#39;t sent anywhere yet.</strong> ' +
+        escapeHtml(tools.slice(0, 3).join(', ')) + (tools.length > 3 ? ' and more' : '') + ' can stop for approval, but when an app calls this agent over HTTP nobody is notified. ' +
+        '<a href="#approvalsSetup" class="approvals-nudge-link">Choose where they go</a></div>';
+    }
+    if (pending.length) html += '<section><h3>Waiting for a decision (' + pending.length + ')</h3>' + renderPendingTable(pending) + '</section>';
+    return html;
   }
 
   function renderApprovalsHtml(n) {
-    return '<section><h3>Approvals when nobody is in Chat</h3><p class="muted" style="margin:0 0 12px">' + renderNotifierStatus(n) + '</p>' +
+    return '<section id="approvalsSetup"><h3>Where approval requests and questions are sent</h3>' +
+      '<p class="muted" style="margin:0 0 8px">When an app calls this agent over HTTP and a tool call needs approval, or the agent asks a question, it&#39;s sent here. In Chat it shows up in the conversation instead.</p>' +
+      '<p class="muted" style="margin:0 0 12px">Currently: ' + renderNotifierStatus(n) + '</p>' +
         (n.error ? '<p class="error">' + escapeHtml(n.error) + '</p>' : '') +
         (n.source === 'code' ? '' : renderNotifierForm(n)) + '</section>' +
       '<section><h3>Recent deliveries</h3>' + renderDeliveries(n.deliveries || []) + '</section>';
@@ -1050,6 +1101,24 @@ ${consoleShellScript}
   function wirePendingHandlers(name) {
     var content = detail.querySelector('#pendingContent');
     if (!content) return;
+    var nudgeLink = content.querySelector('.approvals-nudge-link');
+    if (nudgeLink) {
+      nudgeLink.addEventListener('click', function (ev) {
+        ev.preventDefault();
+        var target = detail.querySelector('#approvalsSetup');
+        if (target) target.scrollIntoView({ behavior: 'smooth', block: 'start' });
+      });
+    }
+    var copyBtns = content.querySelectorAll('.pending-copy');
+    for (var c = 0; c < copyBtns.length; c++) {
+      copyBtns[c].addEventListener('click', function (ev) {
+        var btn = ev.currentTarget;
+        var link = location.origin + btn.dataset.path;
+        var done = function () { btn.textContent = 'Copied'; setTimeout(function () { btn.textContent = 'Copy link'; }, 1500); };
+        if (navigator.clipboard) navigator.clipboard.writeText(link).then(done, function () { window.prompt('Copy this link', link); });
+        else window.prompt('Copy this link', link);
+      });
+    }
     var decideBtns = content.querySelectorAll('.pending-decide');
     for (var i = 0; i < decideBtns.length; i++) {
       decideBtns[i].addEventListener('click', function (ev) {
@@ -1093,13 +1162,59 @@ ${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);
       var channel = data.get('channel');
-      var body = { channel: channel, events: data.getAll('events'), url: data.get('url'), channelId: data.get('channelId'), appId: data.get('appId'), chatId: data.get('chatId') };
+      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),
@@ -1133,11 +1248,12 @@ ${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');
       if (pendingEl) {
-        pendingEl.innerHTML = renderPendingHtml((results[1].ok && results[1].body.pending) || []);
+        pendingEl.innerHTML = renderPendingHtml((results[1].ok && results[1].body.pending) || [], results[0].body);
         wirePendingHandlers(name);
       }
       if (message) { var r = content.querySelector('#notifierResult'); if (r) r.textContent = message; }

package/dist/web/decide-page.d.ts

@@ -0,0 +1,16 @@
+export interface DecidePageItem {
+    kind: 'approval' | 'question';
+    agent: string;
+    tool: string;
+    args: Record<string, unknown>;
+    reason: string;
+    sessionId: string;
+    tenant: string;
+    createdAt?: string;
+    expiresAt: number;
+}
+/** A link that's malformed, tampered with, or past its expiry. */
+export declare function renderDecideInvalidPage(): string;
+/** A valid link whose decision has already been made. */
+export declare function renderDecideGonePage(): string;
+export declare function renderDecidePage(item: DecidePageItem): string;